1
2
3
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/kmap_types.h>
21#include <asm/unaligned.h>
22#include <linux/pagemap.h>
23#include <linux/btrfs.h>
24#include <linux/btrfs_tree.h>
25#include <linux/workqueue.h>
26#include <linux/security.h>
27#include <linux/sizes.h>
28#include <linux/dynamic_debug.h>
29#include <linux/refcount.h>
30#include <linux/crc32c.h>
31#include "extent-io-tree.h"
32#include "extent_io.h"
33#include "extent_map.h"
34#include "async-thread.h"
35#include "block-rsv.h"
36#include "locking.h"
37
38struct btrfs_trans_handle;
39struct btrfs_transaction;
40struct btrfs_pending_snapshot;
41struct btrfs_delayed_ref_root;
42struct btrfs_space_info;
43struct btrfs_block_group;
44extern struct kmem_cache *btrfs_trans_handle_cachep;
45extern struct kmem_cache *btrfs_bit_radix_cachep;
46extern struct kmem_cache *btrfs_path_cachep;
47extern struct kmem_cache *btrfs_free_space_cachep;
48extern struct kmem_cache *btrfs_free_space_bitmap_cachep;
49struct btrfs_ordered_sum;
50struct btrfs_ref;
51
52#define BTRFS_MAGIC 0x4D5F53665248425FULL
53
54
55
56
57
58
59
60
61
62
63#define BTRFS_MAX_MIRRORS (4 + 1)
64
65#define BTRFS_MAX_LEVEL 8
66
67#define BTRFS_OLDEST_GENERATION 0ULL
68
69
70
71
72
73#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
74
75
76
77
78
79#define BTRFS_NAME_LEN 255
80
81
82
83
84
85
86#define BTRFS_LINK_MAX 65535U
87
88#define BTRFS_EMPTY_DIR_SIZE 0
89
90
91#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
92
93#define BTRFS_DIRTY_METADATA_THRESH SZ_32M
94
95
96
97
98
99
100
101#define BTRFS_TOTAL_BYTES_PINNED_BATCH SZ_128M
102
103#define BTRFS_MAX_EXTENT_SIZE SZ_128M
104
105
106
107
108
109
110#define BTRFS_STAT_NR_ENTRIES 2
111#define BTRFS_STAT_CURR 0
112#define BTRFS_STAT_PREV 1
113
114
115
116
117static inline u32 count_max_extents(u64 size)
118{
119 return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
120}
121
122static inline unsigned long btrfs_chunk_item_size(int num_stripes)
123{
124 BUG_ON(num_stripes == 0);
125 return sizeof(struct btrfs_chunk) +
126 sizeof(struct btrfs_stripe) * (num_stripes - 1);
127}
128
129
130
131
132enum {
133
134 BTRFS_FS_STATE_ERROR,
135
136
137
138
139 BTRFS_FS_STATE_REMOUNTING,
140
141 BTRFS_FS_STATE_TRANS_ABORTED,
142
143
144
145
146 BTRFS_FS_STATE_DEV_REPLACING,
147
148 BTRFS_FS_STATE_DUMMY_FS_INFO,
149};
150
151#define BTRFS_BACKREF_REV_MAX 256
152#define BTRFS_BACKREF_REV_SHIFT 56
153#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
154 BTRFS_BACKREF_REV_SHIFT)
155
156#define BTRFS_OLD_BACKREF_REV 0
157#define BTRFS_MIXED_BACKREF_REV 1
158
159
160
161
162struct btrfs_header {
163
164 u8 csum[BTRFS_CSUM_SIZE];
165 u8 fsid[BTRFS_FSID_SIZE];
166 __le64 bytenr;
167 __le64 flags;
168
169
170 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
171 __le64 generation;
172 __le64 owner;
173 __le32 nritems;
174 u8 level;
175} __attribute__ ((__packed__));
176
177
178
179
180
181#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
182
183
184
185
186
187
188#define BTRFS_NUM_BACKUP_ROOTS 4
189struct btrfs_root_backup {
190 __le64 tree_root;
191 __le64 tree_root_gen;
192
193 __le64 chunk_root;
194 __le64 chunk_root_gen;
195
196 __le64 extent_root;
197 __le64 extent_root_gen;
198
199 __le64 fs_root;
200 __le64 fs_root_gen;
201
202 __le64 dev_root;
203 __le64 dev_root_gen;
204
205 __le64 csum_root;
206 __le64 csum_root_gen;
207
208 __le64 total_bytes;
209 __le64 bytes_used;
210 __le64 num_devices;
211
212 __le64 unused_64[4];
213
214 u8 tree_root_level;
215 u8 chunk_root_level;
216 u8 extent_root_level;
217 u8 fs_root_level;
218 u8 dev_root_level;
219 u8 csum_root_level;
220
221 u8 unused_8[10];
222} __attribute__ ((__packed__));
223
224
225
226
227
228struct btrfs_super_block {
229
230 u8 csum[BTRFS_CSUM_SIZE];
231
232 u8 fsid[BTRFS_FSID_SIZE];
233 __le64 bytenr;
234 __le64 flags;
235
236
237 __le64 magic;
238 __le64 generation;
239 __le64 root;
240 __le64 chunk_root;
241 __le64 log_root;
242
243
244 __le64 log_root_transid;
245 __le64 total_bytes;
246 __le64 bytes_used;
247 __le64 root_dir_objectid;
248 __le64 num_devices;
249 __le32 sectorsize;
250 __le32 nodesize;
251 __le32 __unused_leafsize;
252 __le32 stripesize;
253 __le32 sys_chunk_array_size;
254 __le64 chunk_root_generation;
255 __le64 compat_flags;
256 __le64 compat_ro_flags;
257 __le64 incompat_flags;
258 __le16 csum_type;
259 u8 root_level;
260 u8 chunk_root_level;
261 u8 log_root_level;
262 struct btrfs_dev_item dev_item;
263
264 char label[BTRFS_LABEL_SIZE];
265
266 __le64 cache_generation;
267 __le64 uuid_tree_generation;
268
269
270 u8 metadata_uuid[BTRFS_FSID_SIZE];
271
272
273 __le64 reserved[28];
274 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
275 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
276} __attribute__ ((__packed__));
277
278
279
280
281
282#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
283#define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL
284#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL
285
286#define BTRFS_FEATURE_COMPAT_RO_SUPP \
287 (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \
288 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
289
290#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL
291#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL
292
293#define BTRFS_FEATURE_INCOMPAT_SUPP \
294 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
295 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
296 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
297 BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \
298 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \
299 BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD | \
300 BTRFS_FEATURE_INCOMPAT_RAID56 | \
301 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \
302 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \
303 BTRFS_FEATURE_INCOMPAT_NO_HOLES | \
304 BTRFS_FEATURE_INCOMPAT_METADATA_UUID | \
305 BTRFS_FEATURE_INCOMPAT_RAID1C34)
306
307#define BTRFS_FEATURE_INCOMPAT_SAFE_SET \
308 (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
309#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL
310
311
312
313
314
315struct btrfs_item {
316 struct btrfs_disk_key key;
317 __le32 offset;
318 __le32 size;
319} __attribute__ ((__packed__));
320
321
322
323
324
325
326
327
328struct btrfs_leaf {
329 struct btrfs_header header;
330 struct btrfs_item items[];
331} __attribute__ ((__packed__));
332
333
334
335
336
337struct btrfs_key_ptr {
338 struct btrfs_disk_key key;
339 __le64 blockptr;
340 __le64 generation;
341} __attribute__ ((__packed__));
342
343struct btrfs_node {
344 struct btrfs_header header;
345 struct btrfs_key_ptr ptrs[];
346} __attribute__ ((__packed__));
347
348
349
350
351
352
353
354
355
356enum { READA_NONE, READA_BACK, READA_FORWARD };
357struct btrfs_path {
358 struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
359 int slots[BTRFS_MAX_LEVEL];
360
361 u8 locks[BTRFS_MAX_LEVEL];
362 u8 reada;
363
364 u8 lowest_level;
365
366
367
368
369
370 unsigned int search_for_split:1;
371 unsigned int keep_locks:1;
372 unsigned int skip_locking:1;
373 unsigned int leave_spinning:1;
374 unsigned int search_commit_root:1;
375 unsigned int need_commit_sem:1;
376 unsigned int skip_release_on_error:1;
377};
378#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
379 sizeof(struct btrfs_item))
380struct btrfs_dev_replace {
381 u64 replace_state;
382 time64_t time_started;
383 time64_t time_stopped;
384 atomic64_t num_write_errors;
385 atomic64_t num_uncorrectable_read_errors;
386
387 u64 cursor_left;
388 u64 committed_cursor_left;
389 u64 cursor_left_last_write_of_item;
390 u64 cursor_right;
391
392 u64 cont_reading_from_srcdev_mode;
393
394 int is_valid;
395 int item_needs_writeback;
396 struct btrfs_device *srcdev;
397 struct btrfs_device *tgtdev;
398
399 struct mutex lock_finishing_cancel_unmount;
400 struct rw_semaphore rwsem;
401
402 struct btrfs_scrub_progress scrub_progress;
403
404 struct percpu_counter bio_counter;
405 wait_queue_head_t replace_wait;
406};
407
408
409
410
411
412
413struct btrfs_free_cluster {
414 spinlock_t lock;
415 spinlock_t refill_lock;
416 struct rb_root root;
417
418
419 u64 max_size;
420
421
422 u64 window_start;
423
424
425 bool fragmented;
426
427 struct btrfs_block_group *block_group;
428
429
430
431
432
433 struct list_head block_group_list;
434};
435
436enum btrfs_caching_type {
437 BTRFS_CACHE_NO,
438 BTRFS_CACHE_STARTED,
439 BTRFS_CACHE_FAST,
440 BTRFS_CACHE_FINISHED,
441 BTRFS_CACHE_ERROR,
442};
443
444
445
446
447struct btrfs_full_stripe_locks_tree {
448 struct rb_root root;
449 struct mutex lock;
450};
451
452
453
454
455
456
457
458
459
460#define BTRFS_NR_DISCARD_LISTS 3
461#define BTRFS_DISCARD_INDEX_UNUSED 0
462#define BTRFS_DISCARD_INDEX_START 1
463
464struct btrfs_discard_ctl {
465 struct workqueue_struct *discard_workers;
466 struct delayed_work work;
467 spinlock_t lock;
468 struct btrfs_block_group *block_group;
469 struct list_head discard_list[BTRFS_NR_DISCARD_LISTS];
470 u64 prev_discard;
471 atomic_t discardable_extents;
472 atomic64_t discardable_bytes;
473 u64 max_discard_size;
474 unsigned long delay;
475 u32 iops_limit;
476 u32 kbps_limit;
477 u64 discard_extent_bytes;
478 u64 discard_bitmap_bytes;
479 atomic64_t discard_bytes_saved;
480};
481
482
483struct seq_list {
484 struct list_head list;
485 u64 seq;
486};
487
488#define SEQ_LIST_INIT(name) { .list = LIST_HEAD_INIT((name).list), .seq = 0 }
489
490#define SEQ_LAST ((u64)-1)
491
492enum btrfs_orphan_cleanup_state {
493 ORPHAN_CLEANUP_STARTED = 1,
494 ORPHAN_CLEANUP_DONE = 2,
495};
496
497void btrfs_init_async_reclaim_work(struct work_struct *work);
498
499
500struct reloc_control;
501struct btrfs_device;
502struct btrfs_fs_devices;
503struct btrfs_balance_control;
504struct btrfs_delayed_root;
505
506
507
508
509
510
511
512
513
514
515struct btrfs_swapfile_pin {
516 struct rb_node node;
517 void *ptr;
518 struct inode *inode;
519
520
521
522
523 bool is_block_group;
524};
525
526bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);
527
528enum {
529 BTRFS_FS_BARRIER,
530 BTRFS_FS_CLOSING_START,
531 BTRFS_FS_CLOSING_DONE,
532 BTRFS_FS_LOG_RECOVERING,
533 BTRFS_FS_OPEN,
534 BTRFS_FS_QUOTA_ENABLED,
535 BTRFS_FS_UPDATE_UUID_TREE_GEN,
536 BTRFS_FS_CREATING_FREE_SPACE_TREE,
537 BTRFS_FS_BTREE_ERR,
538 BTRFS_FS_LOG1_ERR,
539 BTRFS_FS_LOG2_ERR,
540 BTRFS_FS_QUOTA_OVERRIDE,
541
542 BTRFS_FS_FROZEN,
543
544
545
546
547 BTRFS_FS_EXCL_OP,
548
549
550
551
552 BTRFS_FS_NEED_ASYNC_COMMIT,
553
554
555
556
557
558 BTRFS_FS_BALANCE_RUNNING,
559
560
561 BTRFS_FS_CLEANER_RUNNING,
562
563
564
565
566
567 BTRFS_FS_CSUM_IMPL_FAST,
568
569
570 BTRFS_FS_DISCARD_RUNNING,
571};
572
573struct btrfs_fs_info {
574 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
575 unsigned long flags;
576 struct btrfs_root *extent_root;
577 struct btrfs_root *tree_root;
578 struct btrfs_root *chunk_root;
579 struct btrfs_root *dev_root;
580 struct btrfs_root *fs_root;
581 struct btrfs_root *csum_root;
582 struct btrfs_root *quota_root;
583 struct btrfs_root *uuid_root;
584 struct btrfs_root *free_space_root;
585 struct btrfs_root *data_reloc_root;
586
587
588 struct btrfs_root *log_root_tree;
589
590 spinlock_t fs_roots_radix_lock;
591 struct radix_tree_root fs_roots_radix;
592
593
594 spinlock_t block_group_cache_lock;
595 u64 first_logical_byte;
596 struct rb_root block_group_cache_tree;
597
598
599 atomic64_t free_chunk_space;
600
601
602 struct extent_io_tree excluded_extents;
603
604
605 struct extent_map_tree mapping_tree;
606
607
608
609
610
611 struct btrfs_block_rsv global_block_rsv;
612
613 struct btrfs_block_rsv trans_block_rsv;
614
615 struct btrfs_block_rsv chunk_block_rsv;
616
617 struct btrfs_block_rsv delayed_block_rsv;
618
619 struct btrfs_block_rsv delayed_refs_rsv;
620
621 struct btrfs_block_rsv empty_block_rsv;
622
623 u64 generation;
624 u64 last_trans_committed;
625 u64 avg_delayed_ref_runtime;
626
627
628
629
630
631 u64 last_trans_log_full_commit;
632 unsigned long mount_opt;
633
634
635
636
637 unsigned long pending_changes;
638 unsigned long compress_type:4;
639 unsigned int compress_level;
640 u32 commit_interval;
641
642
643
644
645
646
647 u64 max_inline;
648
649 struct btrfs_transaction *running_transaction;
650 wait_queue_head_t transaction_throttle;
651 wait_queue_head_t transaction_wait;
652 wait_queue_head_t transaction_blocked_wait;
653 wait_queue_head_t async_submit_wait;
654
655
656
657
658
659
660
661
662
663
664
665 spinlock_t super_lock;
666 struct btrfs_super_block *super_copy;
667 struct btrfs_super_block *super_for_commit;
668 struct super_block *sb;
669 struct inode *btree_inode;
670 struct mutex tree_log_mutex;
671 struct mutex transaction_kthread_mutex;
672 struct mutex cleaner_mutex;
673 struct mutex chunk_mutex;
674
675
676
677
678
679 struct mutex ro_block_group_mutex;
680
681
682
683
684
685 struct btrfs_stripe_hash_table *stripe_hash_table;
686
687
688
689
690
691
692
693
694 struct mutex ordered_operations_mutex;
695
696 struct rw_semaphore commit_root_sem;
697
698 struct rw_semaphore cleanup_work_sem;
699
700 struct rw_semaphore subvol_sem;
701
702 spinlock_t trans_lock;
703
704
705
706
707 struct mutex reloc_mutex;
708
709 struct list_head trans_list;
710 struct list_head dead_roots;
711 struct list_head caching_block_groups;
712
713 spinlock_t delayed_iput_lock;
714 struct list_head delayed_iputs;
715 atomic_t nr_delayed_iputs;
716 wait_queue_head_t delayed_iputs_wait;
717
718 atomic64_t tree_mod_seq;
719
720
721 rwlock_t tree_mod_log_lock;
722 struct rb_root tree_mod_log;
723 struct list_head tree_mod_seq_list;
724
725 atomic_t async_delalloc_pages;
726
727
728
729
730 spinlock_t ordered_root_lock;
731
732
733
734
735
736
737
738
739 struct list_head ordered_roots;
740
741 struct mutex delalloc_root_mutex;
742 spinlock_t delalloc_root_lock;
743
744 struct list_head delalloc_roots;
745
746
747
748
749
750
751
752
753
754
755
756 struct btrfs_workqueue *workers;
757 struct btrfs_workqueue *delalloc_workers;
758 struct btrfs_workqueue *flush_workers;
759 struct btrfs_workqueue *endio_workers;
760 struct btrfs_workqueue *endio_meta_workers;
761 struct btrfs_workqueue *endio_raid56_workers;
762 struct btrfs_workqueue *rmw_workers;
763 struct btrfs_workqueue *endio_meta_write_workers;
764 struct btrfs_workqueue *endio_write_workers;
765 struct btrfs_workqueue *endio_freespace_worker;
766 struct btrfs_workqueue *caching_workers;
767 struct btrfs_workqueue *readahead_workers;
768
769
770
771
772
773
774 struct btrfs_workqueue *fixup_workers;
775 struct btrfs_workqueue *delayed_workers;
776
777 struct task_struct *transaction_kthread;
778 struct task_struct *cleaner_kthread;
779 u32 thread_pool_size;
780
781 struct kobject *space_info_kobj;
782
783 u64 total_pinned;
784
785
786 struct percpu_counter dirty_metadata_bytes;
787 struct percpu_counter delalloc_bytes;
788 struct percpu_counter dio_bytes;
789 s32 dirty_metadata_batch;
790 s32 delalloc_batch;
791
792 struct list_head dirty_cowonly_roots;
793
794 struct btrfs_fs_devices *fs_devices;
795
796
797
798
799
800
801 struct list_head space_info;
802
803 struct btrfs_space_info *data_sinfo;
804
805 struct reloc_control *reloc_ctl;
806
807
808 struct btrfs_free_cluster data_alloc_cluster;
809
810
811 struct btrfs_free_cluster meta_alloc_cluster;
812
813
814 spinlock_t defrag_inodes_lock;
815 struct rb_root defrag_inodes;
816 atomic_t defrag_running;
817
818
819 seqlock_t profiles_lock;
820
821
822
823
824
825 u64 avail_data_alloc_bits;
826 u64 avail_metadata_alloc_bits;
827 u64 avail_system_alloc_bits;
828
829
830 spinlock_t balance_lock;
831 struct mutex balance_mutex;
832 atomic_t balance_pause_req;
833 atomic_t balance_cancel_req;
834 struct btrfs_balance_control *balance_ctl;
835 wait_queue_head_t balance_wait_q;
836
837 u32 data_chunk_allocations;
838 u32 metadata_ratio;
839
840 void *bdev_holder;
841
842
843 struct mutex scrub_lock;
844 atomic_t scrubs_running;
845 atomic_t scrub_pause_req;
846 atomic_t scrubs_paused;
847 atomic_t scrub_cancel_req;
848 wait_queue_head_t scrub_pause_wait;
849
850
851
852
853 refcount_t scrub_workers_refcnt;
854 struct btrfs_workqueue *scrub_workers;
855 struct btrfs_workqueue *scrub_wr_completion_workers;
856 struct btrfs_workqueue *scrub_parity_workers;
857
858 struct btrfs_discard_ctl discard_ctl;
859
860#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
861 u32 check_integrity_print_mask;
862#endif
863
864 u64 qgroup_flags;
865
866
867 struct rb_root qgroup_tree;
868 spinlock_t qgroup_lock;
869
870
871
872
873
874 struct ulist *qgroup_ulist;
875
876
877 struct mutex qgroup_ioctl_lock;
878
879
880 struct list_head dirty_qgroups;
881
882
883 u64 qgroup_seq;
884
885
886 struct mutex qgroup_rescan_lock;
887 struct btrfs_key qgroup_rescan_progress;
888 struct btrfs_workqueue *qgroup_rescan_workers;
889 struct completion qgroup_rescan_completion;
890 struct btrfs_work qgroup_rescan_work;
891 bool qgroup_rescan_running;
892
893
894 unsigned long fs_state;
895
896 struct btrfs_delayed_root *delayed_root;
897
898
899 spinlock_t reada_lock;
900 struct radix_tree_root reada_tree;
901
902
903 atomic_t reada_works_cnt;
904
905
906 spinlock_t buffer_lock;
907 struct radix_tree_root buffer_radix;
908
909
910 int backup_root_index;
911
912
913 struct btrfs_dev_replace dev_replace;
914
915 struct semaphore uuid_tree_rescan_sem;
916
917
918 struct work_struct async_reclaim_work;
919
920 spinlock_t unused_bgs_lock;
921 struct list_head unused_bgs;
922 struct mutex unused_bg_unpin_mutex;
923 struct mutex delete_unused_bgs_mutex;
924
925
926 u32 nodesize;
927 u32 sectorsize;
928 u32 stripesize;
929
930
931 spinlock_t swapfile_pins_lock;
932 struct rb_root swapfile_pins;
933
934 struct crypto_shash *csum_shash;
935
936
937
938
939
940 int send_in_progress;
941
942#ifdef CONFIG_BTRFS_FS_REF_VERIFY
943 spinlock_t ref_verify_lock;
944 struct rb_root block_tree;
945#endif
946
947#ifdef CONFIG_BTRFS_DEBUG
948 struct kobject *debug_kobj;
949 struct kobject *discard_debug_kobj;
950 struct list_head allocated_roots;
951
952 spinlock_t eb_leak_lock;
953 struct list_head allocated_ebs;
954#endif
955};
956
957static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
958{
959 return sb->s_fs_info;
960}
961
962
963
964
965enum {
966
967
968
969
970
971
972 BTRFS_ROOT_IN_TRANS_SETUP,
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994 BTRFS_ROOT_SHAREABLE,
995 BTRFS_ROOT_TRACK_DIRTY,
996 BTRFS_ROOT_IN_RADIX,
997 BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
998 BTRFS_ROOT_DEFRAG_RUNNING,
999 BTRFS_ROOT_FORCE_COW,
1000 BTRFS_ROOT_MULTI_LOG_TASKS,
1001 BTRFS_ROOT_DIRTY,
1002 BTRFS_ROOT_DELETING,
1003
1004
1005
1006
1007
1008
1009 BTRFS_ROOT_DEAD_RELOC_TREE,
1010
1011 BTRFS_ROOT_DEAD_TREE,
1012
1013 BTRFS_ROOT_HAS_LOG_TREE,
1014};
1015
1016
1017
1018
1019
1020struct btrfs_qgroup_swapped_blocks {
1021 spinlock_t lock;
1022
1023 bool swapped;
1024 struct rb_root blocks[BTRFS_MAX_LEVEL];
1025};
1026
1027
1028
1029
1030
1031struct btrfs_root {
1032 struct extent_buffer *node;
1033
1034 struct extent_buffer *commit_root;
1035 struct btrfs_root *log_root;
1036 struct btrfs_root *reloc_root;
1037
1038 unsigned long state;
1039 struct btrfs_root_item root_item;
1040 struct btrfs_key root_key;
1041 struct btrfs_fs_info *fs_info;
1042 struct extent_io_tree dirty_log_pages;
1043
1044 struct mutex objectid_mutex;
1045
1046 spinlock_t accounting_lock;
1047 struct btrfs_block_rsv *block_rsv;
1048
1049
1050 struct btrfs_free_space_ctl *free_ino_ctl;
1051 enum btrfs_caching_type ino_cache_state;
1052 spinlock_t ino_cache_lock;
1053 wait_queue_head_t ino_cache_wait;
1054 struct btrfs_free_space_ctl *free_ino_pinned;
1055 u64 ino_cache_progress;
1056 struct inode *ino_cache_inode;
1057
1058 struct mutex log_mutex;
1059 wait_queue_head_t log_writer_wait;
1060 wait_queue_head_t log_commit_wait[2];
1061 struct list_head log_ctxs[2];
1062 atomic_t log_writers;
1063 atomic_t log_commit[2];
1064 atomic_t log_batch;
1065 int log_transid;
1066
1067 int log_transid_committed;
1068
1069 int last_log_commit;
1070 pid_t log_start_pid;
1071
1072 u64 last_trans;
1073
1074 u32 type;
1075
1076 u64 highest_objectid;
1077
1078 u64 defrag_trans_start;
1079 struct btrfs_key defrag_progress;
1080 struct btrfs_key defrag_max;
1081
1082
1083 struct list_head dirty_list;
1084
1085 struct list_head root_list;
1086
1087 spinlock_t log_extents_lock[2];
1088 struct list_head logged_list[2];
1089
1090 int orphan_cleanup_state;
1091
1092 spinlock_t inode_lock;
1093
1094 struct rb_root inode_tree;
1095
1096
1097
1098
1099
1100 struct radix_tree_root delayed_nodes_tree;
1101
1102
1103
1104
1105 dev_t anon_dev;
1106
1107 spinlock_t root_item_lock;
1108 refcount_t refs;
1109
1110 struct mutex delalloc_mutex;
1111 spinlock_t delalloc_lock;
1112
1113
1114
1115
1116
1117 struct list_head delalloc_inodes;
1118 struct list_head delalloc_root;
1119 u64 nr_delalloc_inodes;
1120
1121 struct mutex ordered_extent_mutex;
1122
1123
1124
1125
1126 spinlock_t ordered_extent_lock;
1127
1128
1129
1130
1131
1132
1133 struct list_head ordered_extents;
1134 struct list_head ordered_root;
1135 u64 nr_ordered_extents;
1136
1137
1138
1139
1140
1141
1142
1143 struct list_head reloc_dirty_list;
1144
1145
1146
1147
1148
1149 int send_in_progress;
1150
1151
1152
1153
1154
1155 int dedupe_in_progress;
1156
1157 struct btrfs_drew_lock snapshot_lock;
1158
1159 atomic_t snapshot_force_cow;
1160
1161
1162 spinlock_t qgroup_meta_rsv_lock;
1163 u64 qgroup_meta_rsv_pertrans;
1164 u64 qgroup_meta_rsv_prealloc;
1165
1166
1167 atomic_t nr_swapfiles;
1168
1169
1170 struct btrfs_qgroup_swapped_blocks swapped_blocks;
1171
1172
1173 struct extent_io_tree log_csum_range;
1174
1175#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1176 u64 alloc_bytenr;
1177#endif
1178
1179#ifdef CONFIG_BTRFS_DEBUG
1180 struct list_head leak_list;
1181#endif
1182};
1183
1184struct btrfs_clone_extent_info {
1185 u64 disk_offset;
1186 u64 disk_len;
1187 u64 data_offset;
1188 u64 data_len;
1189 u64 file_offset;
1190 char *extent_buf;
1191 u32 item_size;
1192};
1193
1194struct btrfs_file_private {
1195 void *filldir_buf;
1196};
1197
1198static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
1199{
1200 return btrfs_sb(inode->i_sb)->sectorsize;
1201}
1202
1203static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1204{
1205
1206 return info->nodesize - sizeof(struct btrfs_header);
1207}
1208
1209#define BTRFS_LEAF_DATA_OFFSET offsetof(struct btrfs_leaf, items)
1210
1211static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
1212{
1213 return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
1214}
1215
1216static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
1217{
1218 return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
1219}
1220
1221#define BTRFS_FILE_EXTENT_INLINE_DATA_START \
1222 (offsetof(struct btrfs_file_extent_item, disk_bytenr))
1223static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
1224{
1225 return BTRFS_MAX_ITEM_SIZE(info) -
1226 BTRFS_FILE_EXTENT_INLINE_DATA_START;
1227}
1228
1229static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
1230{
1231 return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
1232}
1233
1234
1235
1236
1237
1238
1239#define BTRFS_MOUNT_NODATASUM (1 << 0)
1240#define BTRFS_MOUNT_NODATACOW (1 << 1)
1241#define BTRFS_MOUNT_NOBARRIER (1 << 2)
1242#define BTRFS_MOUNT_SSD (1 << 3)
1243#define BTRFS_MOUNT_DEGRADED (1 << 4)
1244#define BTRFS_MOUNT_COMPRESS (1 << 5)
1245#define BTRFS_MOUNT_NOTREELOG (1 << 6)
1246#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
1247#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
1248#define BTRFS_MOUNT_NOSSD (1 << 9)
1249#define BTRFS_MOUNT_DISCARD_SYNC (1 << 10)
1250#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
1251#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
1252#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
1253#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
1254#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
1255#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
1256#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
1257#define BTRFS_MOUNT_USEBACKUPROOT (1 << 18)
1258#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
1259#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
1260#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
1261#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22)
1262#define BTRFS_MOUNT_RESCAN_UUID_TREE (1 << 23)
1263#define BTRFS_MOUNT_FRAGMENT_DATA (1 << 24)
1264#define BTRFS_MOUNT_FRAGMENT_METADATA (1 << 25)
1265#define BTRFS_MOUNT_FREE_SPACE_TREE (1 << 26)
1266#define BTRFS_MOUNT_NOLOGREPLAY (1 << 27)
1267#define BTRFS_MOUNT_REF_VERIFY (1 << 28)
1268#define BTRFS_MOUNT_DISCARD_ASYNC (1 << 29)
1269
1270#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
1271#define BTRFS_DEFAULT_MAX_INLINE (2048)
1272
1273#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
1274#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
1275#define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt)
1276#define btrfs_test_opt(fs_info, opt) ((fs_info)->mount_opt & \
1277 BTRFS_MOUNT_##opt)
1278
1279#define btrfs_set_and_info(fs_info, opt, fmt, args...) \
1280{ \
1281 if (!btrfs_test_opt(fs_info, opt)) \
1282 btrfs_info(fs_info, fmt, ##args); \
1283 btrfs_set_opt(fs_info->mount_opt, opt); \
1284}
1285
1286#define btrfs_clear_and_info(fs_info, opt, fmt, args...) \
1287{ \
1288 if (btrfs_test_opt(fs_info, opt)) \
1289 btrfs_info(fs_info, fmt, ##args); \
1290 btrfs_clear_opt(fs_info->mount_opt, opt); \
1291}
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301#define BTRFS_PENDING_SET_INODE_MAP_CACHE (0)
1302#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE (1)
1303#define BTRFS_PENDING_COMMIT (2)
1304
1305#define btrfs_test_pending(info, opt) \
1306 test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1307#define btrfs_set_pending(info, opt) \
1308 set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1309#define btrfs_clear_pending(info, opt) \
1310 clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1311
1312
1313
1314
1315
1316
1317
1318#define btrfs_set_pending_and_info(info, opt, fmt, args...) \
1319do { \
1320 if (!btrfs_raw_test_opt((info)->mount_opt, opt)) { \
1321 btrfs_info((info), fmt, ##args); \
1322 btrfs_set_pending((info), SET_##opt); \
1323 btrfs_clear_pending((info), CLEAR_##opt); \
1324 } \
1325} while(0)
1326
1327#define btrfs_clear_pending_and_info(info, opt, fmt, args...) \
1328do { \
1329 if (btrfs_raw_test_opt((info)->mount_opt, opt)) { \
1330 btrfs_info((info), fmt, ##args); \
1331 btrfs_set_pending((info), CLEAR_##opt); \
1332 btrfs_clear_pending((info), SET_##opt); \
1333 } \
1334} while(0)
1335
1336
1337
1338
1339#define BTRFS_INODE_NODATASUM (1 << 0)
1340#define BTRFS_INODE_NODATACOW (1 << 1)
1341#define BTRFS_INODE_READONLY (1 << 2)
1342#define BTRFS_INODE_NOCOMPRESS (1 << 3)
1343#define BTRFS_INODE_PREALLOC (1 << 4)
1344#define BTRFS_INODE_SYNC (1 << 5)
1345#define BTRFS_INODE_IMMUTABLE (1 << 6)
1346#define BTRFS_INODE_APPEND (1 << 7)
1347#define BTRFS_INODE_NODUMP (1 << 8)
1348#define BTRFS_INODE_NOATIME (1 << 9)
1349#define BTRFS_INODE_DIRSYNC (1 << 10)
1350#define BTRFS_INODE_COMPRESS (1 << 11)
1351
1352#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
1353
1354#define BTRFS_INODE_FLAG_MASK \
1355 (BTRFS_INODE_NODATASUM | \
1356 BTRFS_INODE_NODATACOW | \
1357 BTRFS_INODE_READONLY | \
1358 BTRFS_INODE_NOCOMPRESS | \
1359 BTRFS_INODE_PREALLOC | \
1360 BTRFS_INODE_SYNC | \
1361 BTRFS_INODE_IMMUTABLE | \
1362 BTRFS_INODE_APPEND | \
1363 BTRFS_INODE_NODUMP | \
1364 BTRFS_INODE_NOATIME | \
1365 BTRFS_INODE_DIRSYNC | \
1366 BTRFS_INODE_COMPRESS | \
1367 BTRFS_INODE_ROOT_ITEM_INIT)
1368
1369struct btrfs_map_token {
1370 struct extent_buffer *eb;
1371 char *kaddr;
1372 unsigned long offset;
1373};
1374
1375#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1376 ((bytes) >> (fs_info)->sb->s_blocksize_bits)
1377
1378static inline void btrfs_init_map_token(struct btrfs_map_token *token,
1379 struct extent_buffer *eb)
1380{
1381 token->eb = eb;
1382 token->kaddr = page_address(eb->pages[0]);
1383 token->offset = 0;
1384}
1385
1386
1387
1388
1389
1390#define le8_to_cpu(v) (v)
1391#define cpu_to_le8(v) (v)
1392#define __le8 u8
1393
1394#define read_eb_member(eb, ptr, type, member, result) (\
1395 read_extent_buffer(eb, (char *)(result), \
1396 ((unsigned long)(ptr)) + \
1397 offsetof(type, member), \
1398 sizeof(((type *)0)->member)))
1399
1400#define write_eb_member(eb, ptr, type, member, result) (\
1401 write_extent_buffer(eb, (char *)(result), \
1402 ((unsigned long)(ptr)) + \
1403 offsetof(type, member), \
1404 sizeof(((type *)0)->member)))
1405
1406#define DECLARE_BTRFS_SETGET_BITS(bits) \
1407u##bits btrfs_get_token_##bits(struct btrfs_map_token *token, \
1408 const void *ptr, unsigned long off); \
1409void btrfs_set_token_##bits(struct btrfs_map_token *token, \
1410 const void *ptr, unsigned long off, \
1411 u##bits val); \
1412u##bits btrfs_get_##bits(const struct extent_buffer *eb, \
1413 const void *ptr, unsigned long off); \
1414void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr, \
1415 unsigned long off, u##bits val);
1416
1417DECLARE_BTRFS_SETGET_BITS(8)
1418DECLARE_BTRFS_SETGET_BITS(16)
1419DECLARE_BTRFS_SETGET_BITS(32)
1420DECLARE_BTRFS_SETGET_BITS(64)
1421
1422#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
1423static inline u##bits btrfs_##name(const struct extent_buffer *eb, \
1424 const type *s) \
1425{ \
1426 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1427 return btrfs_get_##bits(eb, s, offsetof(type, member)); \
1428} \
1429static inline void btrfs_set_##name(const struct extent_buffer *eb, type *s, \
1430 u##bits val) \
1431{ \
1432 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1433 btrfs_set_##bits(eb, s, offsetof(type, member), val); \
1434} \
1435static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
1436 const type *s) \
1437{ \
1438 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1439 return btrfs_get_token_##bits(token, s, offsetof(type, member));\
1440} \
1441static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
1442 type *s, u##bits val) \
1443{ \
1444 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1445 btrfs_set_token_##bits(token, s, offsetof(type, member), val); \
1446}
1447
1448#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
1449static inline u##bits btrfs_##name(const struct extent_buffer *eb) \
1450{ \
1451 const type *p = page_address(eb->pages[0]); \
1452 u##bits res = le##bits##_to_cpu(p->member); \
1453 return res; \
1454} \
1455static inline void btrfs_set_##name(const struct extent_buffer *eb, \
1456 u##bits val) \
1457{ \
1458 type *p = page_address(eb->pages[0]); \
1459 p->member = cpu_to_le##bits(val); \
1460}
1461
1462#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
1463static inline u##bits btrfs_##name(const type *s) \
1464{ \
1465 return le##bits##_to_cpu(s->member); \
1466} \
1467static inline void btrfs_set_##name(type *s, u##bits val) \
1468{ \
1469 s->member = cpu_to_le##bits(val); \
1470}
1471
1472
1473static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
1474 struct btrfs_dev_item *s)
1475{
1476 BUILD_BUG_ON(sizeof(u64) !=
1477 sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1478 return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1479 total_bytes));
1480}
1481static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
1482 struct btrfs_dev_item *s,
1483 u64 val)
1484{
1485 BUILD_BUG_ON(sizeof(u64) !=
1486 sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1487 WARN_ON(!IS_ALIGNED(val, eb->fs_info->sectorsize));
1488 btrfs_set_64(eb, s, offsetof(struct btrfs_dev_item, total_bytes), val);
1489}
1490
1491
1492BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1493BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1494BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1495BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1496BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1497 start_offset, 64);
1498BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1499BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1500BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1501BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1502BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1503BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1504
1505BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1506BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1507 total_bytes, 64);
1508BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1509 bytes_used, 64);
1510BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1511 io_align, 32);
1512BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1513 io_width, 32);
1514BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1515 sector_size, 32);
1516BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1517BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1518 dev_group, 32);
1519BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1520 seek_speed, 8);
1521BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1522 bandwidth, 8);
1523BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1524 generation, 64);
1525
1526static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
1527{
1528 return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
1529}
1530
1531static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
1532{
1533 return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
1534}
1535
1536BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1537BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1538BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1539BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1540BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1541BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1542BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1543BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1544BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1545BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1546BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1547
1548static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1549{
1550 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1551}
1552
1553BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1554BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1555BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1556 stripe_len, 64);
1557BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1558 io_align, 32);
1559BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1560 io_width, 32);
1561BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1562 sector_size, 32);
1563BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1564BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1565 num_stripes, 16);
1566BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1567 sub_stripes, 16);
1568BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1569BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1570
1571static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1572 int nr)
1573{
1574 unsigned long offset = (unsigned long)c;
1575 offset += offsetof(struct btrfs_chunk, stripe);
1576 offset += nr * sizeof(struct btrfs_stripe);
1577 return (struct btrfs_stripe *)offset;
1578}
1579
1580static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1581{
1582 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1583}
1584
1585static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
1586 struct btrfs_chunk *c, int nr)
1587{
1588 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1589}
1590
1591static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
1592 struct btrfs_chunk *c, int nr)
1593{
1594 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1595}
1596
1597
1598BTRFS_SETGET_STACK_FUNCS(stack_block_group_used, struct btrfs_block_group_item,
1599 used, 64);
1600BTRFS_SETGET_FUNCS(block_group_used, struct btrfs_block_group_item,
1601 used, 64);
1602BTRFS_SETGET_STACK_FUNCS(stack_block_group_chunk_objectid,
1603 struct btrfs_block_group_item, chunk_objectid, 64);
1604
1605BTRFS_SETGET_FUNCS(block_group_chunk_objectid,
1606 struct btrfs_block_group_item, chunk_objectid, 64);
1607BTRFS_SETGET_FUNCS(block_group_flags,
1608 struct btrfs_block_group_item, flags, 64);
1609BTRFS_SETGET_STACK_FUNCS(stack_block_group_flags,
1610 struct btrfs_block_group_item, flags, 64);
1611
1612
1613BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
1614 extent_count, 32);
1615BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);
1616
1617
1618BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1619BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1620
1621
1622BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
1623 parent_objectid, 64);
1624BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
1625 name_len, 16);
1626BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
1627
1628
1629BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1630BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1631BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1632BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1633BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1634BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1635BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1636BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1637BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1638BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1639BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1640BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1641BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
1642 generation, 64);
1643BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
1644 sequence, 64);
1645BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
1646 transid, 64);
1647BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
1648BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
1649 nbytes, 64);
1650BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
1651 block_group, 64);
1652BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
1653BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
1654BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
1655BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
1656BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
1657BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
1658BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1659BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1660BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
1661BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
1662
1663
1664BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1665 chunk_tree, 64);
1666BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1667 chunk_objectid, 64);
1668BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1669 chunk_offset, 64);
1670BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1671BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1672BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1673 generation, 64);
1674BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1675
1676BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1677
1678static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
1679 struct btrfs_tree_block_info *item,
1680 struct btrfs_disk_key *key)
1681{
1682 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1683}
1684
1685static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
1686 struct btrfs_tree_block_info *item,
1687 struct btrfs_disk_key *key)
1688{
1689 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1690}
1691
1692BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1693 root, 64);
1694BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1695 objectid, 64);
1696BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1697 offset, 64);
1698BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1699 count, 32);
1700
1701BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1702 count, 32);
1703
1704BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1705 type, 8);
1706BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1707 offset, 64);
1708
1709static inline u32 btrfs_extent_inline_ref_size(int type)
1710{
1711 if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1712 type == BTRFS_SHARED_BLOCK_REF_KEY)
1713 return sizeof(struct btrfs_extent_inline_ref);
1714 if (type == BTRFS_SHARED_DATA_REF_KEY)
1715 return sizeof(struct btrfs_shared_data_ref) +
1716 sizeof(struct btrfs_extent_inline_ref);
1717 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1718 return sizeof(struct btrfs_extent_data_ref) +
1719 offsetof(struct btrfs_extent_inline_ref, offset);
1720 return 0;
1721}
1722
1723
1724BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1725BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1726BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
1727 blockptr, 64);
1728BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1729 generation, 64);
1730
1731static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
1732{
1733 unsigned long ptr;
1734 ptr = offsetof(struct btrfs_node, ptrs) +
1735 sizeof(struct btrfs_key_ptr) * nr;
1736 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1737}
1738
1739static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
1740 int nr, u64 val)
1741{
1742 unsigned long ptr;
1743 ptr = offsetof(struct btrfs_node, ptrs) +
1744 sizeof(struct btrfs_key_ptr) * nr;
1745 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1746}
1747
1748static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
1749{
1750 unsigned long ptr;
1751 ptr = offsetof(struct btrfs_node, ptrs) +
1752 sizeof(struct btrfs_key_ptr) * nr;
1753 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1754}
1755
1756static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
1757 int nr, u64 val)
1758{
1759 unsigned long ptr;
1760 ptr = offsetof(struct btrfs_node, ptrs) +
1761 sizeof(struct btrfs_key_ptr) * nr;
1762 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1763}
1764
1765static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1766{
1767 return offsetof(struct btrfs_node, ptrs) +
1768 sizeof(struct btrfs_key_ptr) * nr;
1769}
1770
1771void btrfs_node_key(const struct extent_buffer *eb,
1772 struct btrfs_disk_key *disk_key, int nr);
1773
1774static inline void btrfs_set_node_key(const struct extent_buffer *eb,
1775 struct btrfs_disk_key *disk_key, int nr)
1776{
1777 unsigned long ptr;
1778 ptr = btrfs_node_key_ptr_offset(nr);
1779 write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
1780 struct btrfs_key_ptr, key, disk_key);
1781}
1782
1783
1784BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1785BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1786BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
1787BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
1788
1789static inline unsigned long btrfs_item_nr_offset(int nr)
1790{
1791 return offsetof(struct btrfs_leaf, items) +
1792 sizeof(struct btrfs_item) * nr;
1793}
1794
1795static inline struct btrfs_item *btrfs_item_nr(int nr)
1796{
1797 return (struct btrfs_item *)btrfs_item_nr_offset(nr);
1798}
1799
1800static inline u32 btrfs_item_end(const struct extent_buffer *eb,
1801 struct btrfs_item *item)
1802{
1803 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
1804}
1805
1806static inline u32 btrfs_item_end_nr(const struct extent_buffer *eb, int nr)
1807{
1808 return btrfs_item_end(eb, btrfs_item_nr(nr));
1809}
1810
1811static inline u32 btrfs_item_offset_nr(const struct extent_buffer *eb, int nr)
1812{
1813 return btrfs_item_offset(eb, btrfs_item_nr(nr));
1814}
1815
1816static inline u32 btrfs_item_size_nr(const struct extent_buffer *eb, int nr)
1817{
1818 return btrfs_item_size(eb, btrfs_item_nr(nr));
1819}
1820
1821static inline void btrfs_item_key(const struct extent_buffer *eb,
1822 struct btrfs_disk_key *disk_key, int nr)
1823{
1824 struct btrfs_item *item = btrfs_item_nr(nr);
1825 read_eb_member(eb, item, struct btrfs_item, key, disk_key);
1826}
1827
1828static inline void btrfs_set_item_key(struct extent_buffer *eb,
1829 struct btrfs_disk_key *disk_key, int nr)
1830{
1831 struct btrfs_item *item = btrfs_item_nr(nr);
1832 write_eb_member(eb, item, struct btrfs_item, key, disk_key);
1833}
1834
1835BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1836
1837
1838
1839
1840BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
1841BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
1842BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
1843
1844
1845BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
1846BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
1847BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
1848BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
1849BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
1850BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
1851 data_len, 16);
1852BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
1853 name_len, 16);
1854BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
1855 transid, 64);
1856
1857static inline void btrfs_dir_item_key(const struct extent_buffer *eb,
1858 const struct btrfs_dir_item *item,
1859 struct btrfs_disk_key *key)
1860{
1861 read_eb_member(eb, item, struct btrfs_dir_item, location, key);
1862}
1863
1864static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
1865 struct btrfs_dir_item *item,
1866 const struct btrfs_disk_key *key)
1867{
1868 write_eb_member(eb, item, struct btrfs_dir_item, location, key);
1869}
1870
1871BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
1872 num_entries, 64);
1873BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
1874 num_bitmaps, 64);
1875BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
1876 generation, 64);
1877
1878static inline void btrfs_free_space_key(const struct extent_buffer *eb,
1879 const struct btrfs_free_space_header *h,
1880 struct btrfs_disk_key *key)
1881{
1882 read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1883}
1884
1885static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
1886 struct btrfs_free_space_header *h,
1887 const struct btrfs_disk_key *key)
1888{
1889 write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1890}
1891
1892
1893BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
1894 objectid, 64);
1895BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
1896BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
1897
1898static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
1899 const struct btrfs_disk_key *disk)
1900{
1901 cpu->offset = le64_to_cpu(disk->offset);
1902 cpu->type = disk->type;
1903 cpu->objectid = le64_to_cpu(disk->objectid);
1904}
1905
1906static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
1907 const struct btrfs_key *cpu)
1908{
1909 disk->offset = cpu_to_le64(cpu->offset);
1910 disk->type = cpu->type;
1911 disk->objectid = cpu_to_le64(cpu->objectid);
1912}
1913
1914static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
1915 struct btrfs_key *key, int nr)
1916{
1917 struct btrfs_disk_key disk_key;
1918 btrfs_node_key(eb, &disk_key, nr);
1919 btrfs_disk_key_to_cpu(key, &disk_key);
1920}
1921
1922static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
1923 struct btrfs_key *key, int nr)
1924{
1925 struct btrfs_disk_key disk_key;
1926 btrfs_item_key(eb, &disk_key, nr);
1927 btrfs_disk_key_to_cpu(key, &disk_key);
1928}
1929
1930static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
1931 const struct btrfs_dir_item *item,
1932 struct btrfs_key *key)
1933{
1934 struct btrfs_disk_key disk_key;
1935 btrfs_dir_item_key(eb, item, &disk_key);
1936 btrfs_disk_key_to_cpu(key, &disk_key);
1937}
1938
1939
1940BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
1941BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
1942 generation, 64);
1943BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
1944BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
1945BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
1946BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
1947BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
1948 generation, 64);
1949BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
1950BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
1951 nritems, 32);
1952BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
1953
1954static inline int btrfs_header_flag(const struct extent_buffer *eb, u64 flag)
1955{
1956 return (btrfs_header_flags(eb) & flag) == flag;
1957}
1958
1959static inline void btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
1960{
1961 u64 flags = btrfs_header_flags(eb);
1962 btrfs_set_header_flags(eb, flags | flag);
1963}
1964
1965static inline void btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
1966{
1967 u64 flags = btrfs_header_flags(eb);
1968 btrfs_set_header_flags(eb, flags & ~flag);
1969}
1970
1971static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
1972{
1973 u64 flags = btrfs_header_flags(eb);
1974 return flags >> BTRFS_BACKREF_REV_SHIFT;
1975}
1976
1977static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
1978 int rev)
1979{
1980 u64 flags = btrfs_header_flags(eb);
1981 flags &= ~BTRFS_BACKREF_REV_MASK;
1982 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
1983 btrfs_set_header_flags(eb, flags);
1984}
1985
1986static inline int btrfs_is_leaf(const struct extent_buffer *eb)
1987{
1988 return btrfs_header_level(eb) == 0;
1989}
1990
1991
1992BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
1993 generation, 64);
1994BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
1995BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
1996BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
1997
1998BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
1999 generation, 64);
2000BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2001BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2002BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2003BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2004BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2005BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2006BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
2007BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2008 last_snapshot, 64);
2009BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2010 generation_v2, 64);
2011BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2012 ctransid, 64);
2013BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2014 otransid, 64);
2015BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2016 stransid, 64);
2017BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2018 rtransid, 64);
2019
2020static inline bool btrfs_root_readonly(const struct btrfs_root *root)
2021{
2022 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
2023}
2024
2025static inline bool btrfs_root_dead(const struct btrfs_root *root)
2026{
2027 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
2028}
2029
2030
2031BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2032 tree_root, 64);
2033BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2034 tree_root_gen, 64);
2035BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2036 tree_root_level, 8);
2037
2038BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2039 chunk_root, 64);
2040BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2041 chunk_root_gen, 64);
2042BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2043 chunk_root_level, 8);
2044
2045BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2046 extent_root, 64);
2047BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2048 extent_root_gen, 64);
2049BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2050 extent_root_level, 8);
2051
2052BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2053 fs_root, 64);
2054BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2055 fs_root_gen, 64);
2056BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2057 fs_root_level, 8);
2058
2059BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2060 dev_root, 64);
2061BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2062 dev_root_gen, 64);
2063BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2064 dev_root_level, 8);
2065
2066BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2067 csum_root, 64);
2068BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2069 csum_root_gen, 64);
2070BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2071 csum_root_level, 8);
2072BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2073 total_bytes, 64);
2074BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2075 bytes_used, 64);
2076BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2077 num_devices, 64);
2078
2079
2080BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2081
2082static inline void btrfs_balance_data(const struct extent_buffer *eb,
2083 const struct btrfs_balance_item *bi,
2084 struct btrfs_disk_balance_args *ba)
2085{
2086 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2087}
2088
2089static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2090 struct btrfs_balance_item *bi,
2091 const struct btrfs_disk_balance_args *ba)
2092{
2093 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2094}
2095
2096static inline void btrfs_balance_meta(const struct extent_buffer *eb,
2097 const struct btrfs_balance_item *bi,
2098 struct btrfs_disk_balance_args *ba)
2099{
2100 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2101}
2102
2103static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2104 struct btrfs_balance_item *bi,
2105 const struct btrfs_disk_balance_args *ba)
2106{
2107 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2108}
2109
2110static inline void btrfs_balance_sys(const struct extent_buffer *eb,
2111 const struct btrfs_balance_item *bi,
2112 struct btrfs_disk_balance_args *ba)
2113{
2114 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2115}
2116
2117static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2118 struct btrfs_balance_item *bi,
2119 const struct btrfs_disk_balance_args *ba)
2120{
2121 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2122}
2123
2124static inline void
2125btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2126 const struct btrfs_disk_balance_args *disk)
2127{
2128 memset(cpu, 0, sizeof(*cpu));
2129
2130 cpu->profiles = le64_to_cpu(disk->profiles);
2131 cpu->usage = le64_to_cpu(disk->usage);
2132 cpu->devid = le64_to_cpu(disk->devid);
2133 cpu->pstart = le64_to_cpu(disk->pstart);
2134 cpu->pend = le64_to_cpu(disk->pend);
2135 cpu->vstart = le64_to_cpu(disk->vstart);
2136 cpu->vend = le64_to_cpu(disk->vend);
2137 cpu->target = le64_to_cpu(disk->target);
2138 cpu->flags = le64_to_cpu(disk->flags);
2139 cpu->limit = le64_to_cpu(disk->limit);
2140 cpu->stripes_min = le32_to_cpu(disk->stripes_min);
2141 cpu->stripes_max = le32_to_cpu(disk->stripes_max);
2142}
2143
2144static inline void
2145btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2146 const struct btrfs_balance_args *cpu)
2147{
2148 memset(disk, 0, sizeof(*disk));
2149
2150 disk->profiles = cpu_to_le64(cpu->profiles);
2151 disk->usage = cpu_to_le64(cpu->usage);
2152 disk->devid = cpu_to_le64(cpu->devid);
2153 disk->pstart = cpu_to_le64(cpu->pstart);
2154 disk->pend = cpu_to_le64(cpu->pend);
2155 disk->vstart = cpu_to_le64(cpu->vstart);
2156 disk->vend = cpu_to_le64(cpu->vend);
2157 disk->target = cpu_to_le64(cpu->target);
2158 disk->flags = cpu_to_le64(cpu->flags);
2159 disk->limit = cpu_to_le64(cpu->limit);
2160 disk->stripes_min = cpu_to_le32(cpu->stripes_min);
2161 disk->stripes_max = cpu_to_le32(cpu->stripes_max);
2162}
2163
2164
2165BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2166BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2167BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2168 generation, 64);
2169BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2170BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2171 struct btrfs_super_block, sys_chunk_array_size, 32);
2172BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2173 struct btrfs_super_block, chunk_root_generation, 64);
2174BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2175 root_level, 8);
2176BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2177 chunk_root, 64);
2178BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2179 chunk_root_level, 8);
2180BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2181 log_root, 64);
2182BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2183 log_root_transid, 64);
2184BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2185 log_root_level, 8);
2186BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2187 total_bytes, 64);
2188BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2189 bytes_used, 64);
2190BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2191 sectorsize, 32);
2192BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2193 nodesize, 32);
2194BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2195 stripesize, 32);
2196BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2197 root_dir_objectid, 64);
2198BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2199 num_devices, 64);
2200BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2201 compat_flags, 64);
2202BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2203 compat_ro_flags, 64);
2204BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2205 incompat_flags, 64);
2206BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2207 csum_type, 16);
2208BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2209 cache_generation, 64);
2210BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
2211BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2212 uuid_tree_generation, 64);
2213
2214int btrfs_super_csum_size(const struct btrfs_super_block *s);
2215const char *btrfs_super_csum_name(u16 csum_type);
2216const char *btrfs_super_csum_driver(u16 csum_type);
2217size_t __const btrfs_get_num_csums(void);
2218
2219
2220
2221
2222
2223
2224
2225static inline unsigned int leaf_data_end(const struct extent_buffer *leaf)
2226{
2227 u32 nr = btrfs_header_nritems(leaf);
2228
2229 if (nr == 0)
2230 return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
2231 return btrfs_item_offset_nr(leaf, nr - 1);
2232}
2233
2234
2235BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2236BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2237 struct btrfs_file_extent_item, disk_bytenr, 64);
2238BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
2239 struct btrfs_file_extent_item, offset, 64);
2240BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
2241 struct btrfs_file_extent_item, generation, 64);
2242BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2243 struct btrfs_file_extent_item, num_bytes, 64);
2244BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2245 struct btrfs_file_extent_item, disk_num_bytes, 64);
2246BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
2247 struct btrfs_file_extent_item, compression, 8);
2248
2249static inline unsigned long
2250btrfs_file_extent_inline_start(const struct btrfs_file_extent_item *e)
2251{
2252 return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
2253}
2254
2255static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2256{
2257 return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2258}
2259
2260BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2261 disk_bytenr, 64);
2262BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2263 generation, 64);
2264BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2265 disk_num_bytes, 64);
2266BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2267 offset, 64);
2268BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2269 num_bytes, 64);
2270BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2271 ram_bytes, 64);
2272BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2273 compression, 8);
2274BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2275 encryption, 8);
2276BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2277 other_encoding, 16);
2278
2279
2280
2281
2282
2283
2284static inline u32 btrfs_file_extent_inline_item_len(
2285 const struct extent_buffer *eb,
2286 struct btrfs_item *e)
2287{
2288 return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
2289}
2290
2291
2292BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2293 generation, 64);
2294BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2295 version, 64);
2296BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2297 flags, 64);
2298BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
2299 rescan, 64);
2300
2301
2302BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2303 generation, 64);
2304BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2305BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2306 rfer_cmpr, 64);
2307BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2308BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2309 excl_cmpr, 64);
2310
2311BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2312 struct btrfs_qgroup_info_item, generation, 64);
2313BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2314 rfer, 64);
2315BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2316 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2317BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2318 excl, 64);
2319BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2320 struct btrfs_qgroup_info_item, excl_cmpr, 64);
2321
2322
2323BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2324 flags, 64);
2325BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2326 max_rfer, 64);
2327BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2328 max_excl, 64);
2329BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2330 rsv_rfer, 64);
2331BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2332 rsv_excl, 64);
2333
2334
2335BTRFS_SETGET_FUNCS(dev_replace_src_devid,
2336 struct btrfs_dev_replace_item, src_devid, 64);
2337BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
2338 struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
2339 64);
2340BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
2341 replace_state, 64);
2342BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
2343 time_started, 64);
2344BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
2345 time_stopped, 64);
2346BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
2347 num_write_errors, 64);
2348BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
2349 struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
2350 64);
2351BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
2352 cursor_left, 64);
2353BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
2354 cursor_right, 64);
2355
2356BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
2357 struct btrfs_dev_replace_item, src_devid, 64);
2358BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
2359 struct btrfs_dev_replace_item,
2360 cont_reading_from_srcdev_mode, 64);
2361BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
2362 struct btrfs_dev_replace_item, replace_state, 64);
2363BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
2364 struct btrfs_dev_replace_item, time_started, 64);
2365BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
2366 struct btrfs_dev_replace_item, time_stopped, 64);
2367BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
2368 struct btrfs_dev_replace_item, num_write_errors, 64);
2369BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
2370 struct btrfs_dev_replace_item,
2371 num_uncorrectable_read_errors, 64);
2372BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
2373 struct btrfs_dev_replace_item, cursor_left, 64);
2374BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
2375 struct btrfs_dev_replace_item, cursor_right, 64);
2376
2377
2378#define btrfs_item_ptr(leaf, slot, type) \
2379 ((type *)(BTRFS_LEAF_DATA_OFFSET + \
2380 btrfs_item_offset_nr(leaf, slot)))
2381
2382#define btrfs_item_ptr_offset(leaf, slot) \
2383 ((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \
2384 btrfs_item_offset_nr(leaf, slot)))
2385
2386static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length)
2387{
2388 return crc32c(crc, address, length);
2389}
2390
2391static inline void btrfs_crc32c_final(u32 crc, u8 *result)
2392{
2393 put_unaligned_le32(~crc, result);
2394}
2395
2396static inline u64 btrfs_name_hash(const char *name, int len)
2397{
2398 return crc32c((u32)~1, name, len);
2399}
2400
2401
2402
2403
2404static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,
2405 int len)
2406{
2407 return (u64) crc32c(parent_objectid, name, len);
2408}
2409
2410static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2411{
2412 return mapping_gfp_constraint(mapping, ~__GFP_FS);
2413}
2414
2415
2416
2417enum btrfs_inline_ref_type {
2418 BTRFS_REF_TYPE_INVALID,
2419 BTRFS_REF_TYPE_BLOCK,
2420 BTRFS_REF_TYPE_DATA,
2421 BTRFS_REF_TYPE_ANY,
2422};
2423
2424int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
2425 struct btrfs_extent_inline_ref *iref,
2426 enum btrfs_inline_ref_type is_data);
2427u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset);
2428
2429u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
2430
2431
2432
2433
2434
2435static inline u64 btrfs_calc_insert_metadata_size(struct btrfs_fs_info *fs_info,
2436 unsigned num_items)
2437{
2438 return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2439}
2440
2441
2442
2443
2444
2445static inline u64 btrfs_calc_metadata_size(struct btrfs_fs_info *fs_info,
2446 unsigned num_items)
2447{
2448 return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2449}
2450
2451int btrfs_add_excluded_extent(struct btrfs_fs_info *fs_info,
2452 u64 start, u64 num_bytes);
2453void btrfs_free_excluded_extents(struct btrfs_block_group *cache);
2454int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2455 unsigned long count);
2456void btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,
2457 struct btrfs_delayed_ref_root *delayed_refs,
2458 struct btrfs_delayed_ref_head *head);
2459int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2460int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2461 struct btrfs_fs_info *fs_info, u64 bytenr,
2462 u64 offset, int metadata, u64 *refs, u64 *flags);
2463int btrfs_pin_extent(struct btrfs_trans_handle *trans, u64 bytenr, u64 num,
2464 int reserved);
2465int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2466 u64 bytenr, u64 num_bytes);
2467int btrfs_exclude_logged_extents(struct extent_buffer *eb);
2468int btrfs_cross_ref_exist(struct btrfs_root *root,
2469 u64 objectid, u64 offset, u64 bytenr);
2470struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
2471 struct btrfs_root *root,
2472 u64 parent, u64 root_objectid,
2473 const struct btrfs_disk_key *key,
2474 int level, u64 hint,
2475 u64 empty_size);
2476void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2477 struct btrfs_root *root,
2478 struct extent_buffer *buf,
2479 u64 parent, int last_ref);
2480int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
2481 struct btrfs_root *root, u64 owner,
2482 u64 offset, u64 ram_bytes,
2483 struct btrfs_key *ins);
2484int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2485 u64 root_objectid, u64 owner, u64 offset,
2486 struct btrfs_key *ins);
2487int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes, u64 num_bytes,
2488 u64 min_alloc_size, u64 empty_size, u64 hint_byte,
2489 struct btrfs_key *ins, int is_data, int delalloc);
2490int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2491 struct extent_buffer *buf, int full_backref);
2492int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2493 struct extent_buffer *buf, int full_backref);
2494int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2495 struct extent_buffer *eb, u64 flags,
2496 int level, int is_data);
2497int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref);
2498
2499int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2500 u64 start, u64 len, int delalloc);
2501int btrfs_pin_reserved_extent(struct btrfs_trans_handle *trans, u64 start,
2502 u64 len);
2503void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info);
2504int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans);
2505int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2506 struct btrfs_ref *generic_ref);
2507
2508int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
2509void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2510
2511enum btrfs_reserve_flush_enum {
2512
2513 BTRFS_RESERVE_NO_FLUSH,
2514
2515
2516
2517
2518 BTRFS_RESERVE_FLUSH_LIMIT,
2519 BTRFS_RESERVE_FLUSH_EVICT,
2520 BTRFS_RESERVE_FLUSH_ALL,
2521 BTRFS_RESERVE_FLUSH_ALL_STEAL,
2522};
2523
2524enum btrfs_flush_state {
2525 FLUSH_DELAYED_ITEMS_NR = 1,
2526 FLUSH_DELAYED_ITEMS = 2,
2527 FLUSH_DELAYED_REFS_NR = 3,
2528 FLUSH_DELAYED_REFS = 4,
2529 FLUSH_DELALLOC = 5,
2530 FLUSH_DELALLOC_WAIT = 6,
2531 ALLOC_CHUNK = 7,
2532 ALLOC_CHUNK_FORCE = 8,
2533 RUN_DELAYED_IPUTS = 9,
2534 COMMIT_TRANS = 10,
2535};
2536
2537int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2538 struct btrfs_block_rsv *rsv,
2539 int nitems, bool use_global_rsv);
2540void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
2541 struct btrfs_block_rsv *rsv);
2542void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes);
2543
2544int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
2545u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2546int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
2547 u64 start, u64 end);
2548int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2549 u64 num_bytes, u64 *actual_bytes);
2550int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
2551
2552int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
2553int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2554 struct btrfs_fs_info *fs_info);
2555int btrfs_start_write_no_snapshotting(struct btrfs_root *root);
2556void btrfs_end_write_no_snapshotting(struct btrfs_root *root);
2557void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
2558
2559
2560int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
2561 int *slot);
2562int __pure btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2);
2563int btrfs_previous_item(struct btrfs_root *root,
2564 struct btrfs_path *path, u64 min_objectid,
2565 int type);
2566int btrfs_previous_extent_item(struct btrfs_root *root,
2567 struct btrfs_path *path, u64 min_objectid);
2568void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
2569 struct btrfs_path *path,
2570 const struct btrfs_key *new_key);
2571struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2572struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2573struct extent_buffer *btrfs_read_lock_root_node(struct btrfs_root *root);
2574int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2575 struct btrfs_key *key, int lowest_level,
2576 u64 min_trans);
2577int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2578 struct btrfs_path *path,
2579 u64 min_trans);
2580struct extent_buffer *btrfs_read_node_slot(struct extent_buffer *parent,
2581 int slot);
2582
2583int btrfs_cow_block(struct btrfs_trans_handle *trans,
2584 struct btrfs_root *root, struct extent_buffer *buf,
2585 struct extent_buffer *parent, int parent_slot,
2586 struct extent_buffer **cow_ret);
2587int btrfs_copy_root(struct btrfs_trans_handle *trans,
2588 struct btrfs_root *root,
2589 struct extent_buffer *buf,
2590 struct extent_buffer **cow_ret, u64 new_root_objectid);
2591int btrfs_block_can_be_shared(struct btrfs_root *root,
2592 struct extent_buffer *buf);
2593void btrfs_extend_item(struct btrfs_path *path, u32 data_size);
2594void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end);
2595int btrfs_split_item(struct btrfs_trans_handle *trans,
2596 struct btrfs_root *root,
2597 struct btrfs_path *path,
2598 const struct btrfs_key *new_key,
2599 unsigned long split_offset);
2600int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2601 struct btrfs_root *root,
2602 struct btrfs_path *path,
2603 const struct btrfs_key *new_key);
2604int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
2605 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
2606int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2607 const struct btrfs_key *key, struct btrfs_path *p,
2608 int ins_len, int cow);
2609int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
2610 struct btrfs_path *p, u64 time_seq);
2611int btrfs_search_slot_for_read(struct btrfs_root *root,
2612 const struct btrfs_key *key,
2613 struct btrfs_path *p, int find_higher,
2614 int return_any);
2615int btrfs_realloc_node(struct btrfs_trans_handle *trans,
2616 struct btrfs_root *root, struct extent_buffer *parent,
2617 int start_slot, u64 *last_ret,
2618 struct btrfs_key *progress);
2619void btrfs_release_path(struct btrfs_path *p);
2620struct btrfs_path *btrfs_alloc_path(void);
2621void btrfs_free_path(struct btrfs_path *p);
2622
2623int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2624 struct btrfs_path *path, int slot, int nr);
2625static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2626 struct btrfs_root *root,
2627 struct btrfs_path *path)
2628{
2629 return btrfs_del_items(trans, root, path, path->slots[0], 1);
2630}
2631
2632void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
2633 const struct btrfs_key *cpu_key, u32 *data_size,
2634 u32 total_data, u32 total_size, int nr);
2635int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2636 const struct btrfs_key *key, void *data, u32 data_size);
2637int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
2638 struct btrfs_root *root,
2639 struct btrfs_path *path,
2640 const struct btrfs_key *cpu_key, u32 *data_size,
2641 int nr);
2642
2643static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
2644 struct btrfs_root *root,
2645 struct btrfs_path *path,
2646 const struct btrfs_key *key,
2647 u32 data_size)
2648{
2649 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
2650}
2651
2652int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
2653int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
2654int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
2655 u64 time_seq);
2656static inline int btrfs_next_old_item(struct btrfs_root *root,
2657 struct btrfs_path *p, u64 time_seq)
2658{
2659 ++p->slots[0];
2660 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
2661 return btrfs_next_old_leaf(root, p, time_seq);
2662 return 0;
2663}
2664static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
2665{
2666 return btrfs_next_old_item(root, p, 0);
2667}
2668int btrfs_leaf_free_space(struct extent_buffer *leaf);
2669int __must_check btrfs_drop_snapshot(struct btrfs_root *root, int update_ref,
2670 int for_reloc);
2671int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2672 struct btrfs_root *root,
2673 struct extent_buffer *node,
2674 struct extent_buffer *parent);
2675static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
2676{
2677
2678
2679
2680 if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
2681 if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
2682 return 2;
2683 return 1;
2684 }
2685 return 0;
2686}
2687
2688
2689
2690
2691
2692
2693static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
2694{
2695 return fs_info->sb->s_flags & SB_RDONLY || btrfs_fs_closing(fs_info);
2696}
2697
2698
2699u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
2700 struct seq_list *elem);
2701void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
2702 struct seq_list *elem);
2703int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
2704
2705
2706int btrfs_add_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
2707 u64 ref_id, u64 dirid, u64 sequence, const char *name,
2708 int name_len);
2709int btrfs_del_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
2710 u64 ref_id, u64 dirid, u64 *sequence, const char *name,
2711 int name_len);
2712int btrfs_del_root(struct btrfs_trans_handle *trans,
2713 const struct btrfs_key *key);
2714int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2715 const struct btrfs_key *key,
2716 struct btrfs_root_item *item);
2717int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
2718 struct btrfs_root *root,
2719 struct btrfs_key *key,
2720 struct btrfs_root_item *item);
2721int btrfs_find_root(struct btrfs_root *root, const struct btrfs_key *search_key,
2722 struct btrfs_path *path, struct btrfs_root_item *root_item,
2723 struct btrfs_key *root_key);
2724int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);
2725void btrfs_set_root_node(struct btrfs_root_item *item,
2726 struct extent_buffer *node);
2727void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
2728void btrfs_update_root_times(struct btrfs_trans_handle *trans,
2729 struct btrfs_root *root);
2730
2731
2732int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
2733 u64 subid);
2734int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
2735 u64 subid);
2736int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info);
2737
2738
2739int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
2740 const char *name, int name_len);
2741int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, const char *name,
2742 int name_len, struct btrfs_inode *dir,
2743 struct btrfs_key *location, u8 type, u64 index);
2744struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
2745 struct btrfs_root *root,
2746 struct btrfs_path *path, u64 dir,
2747 const char *name, int name_len,
2748 int mod);
2749struct btrfs_dir_item *
2750btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
2751 struct btrfs_root *root,
2752 struct btrfs_path *path, u64 dir,
2753 u64 objectid, const char *name, int name_len,
2754 int mod);
2755struct btrfs_dir_item *
2756btrfs_search_dir_index_item(struct btrfs_root *root,
2757 struct btrfs_path *path, u64 dirid,
2758 const char *name, int name_len);
2759int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
2760 struct btrfs_root *root,
2761 struct btrfs_path *path,
2762 struct btrfs_dir_item *di);
2763int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
2764 struct btrfs_root *root,
2765 struct btrfs_path *path, u64 objectid,
2766 const char *name, u16 name_len,
2767 const void *data, u16 data_len);
2768struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
2769 struct btrfs_root *root,
2770 struct btrfs_path *path, u64 dir,
2771 const char *name, u16 name_len,
2772 int mod);
2773struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,
2774 struct btrfs_path *path,
2775 const char *name,
2776 int name_len);
2777
2778
2779int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
2780 struct btrfs_root *root, u64 offset);
2781int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
2782 struct btrfs_root *root, u64 offset);
2783int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
2784
2785
2786int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
2787 struct btrfs_root *root,
2788 const char *name, int name_len,
2789 u64 inode_objectid, u64 ref_objectid, u64 index);
2790int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
2791 struct btrfs_root *root,
2792 const char *name, int name_len,
2793 u64 inode_objectid, u64 ref_objectid, u64 *index);
2794int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
2795 struct btrfs_root *root,
2796 struct btrfs_path *path, u64 objectid);
2797int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
2798 *root, struct btrfs_path *path,
2799 struct btrfs_key *location, int mod);
2800
2801struct btrfs_inode_extref *
2802btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
2803 struct btrfs_root *root,
2804 struct btrfs_path *path,
2805 const char *name, int name_len,
2806 u64 inode_objectid, u64 ref_objectid, int ins_len,
2807 int cow);
2808
2809struct btrfs_inode_ref *btrfs_find_name_in_backref(struct extent_buffer *leaf,
2810 int slot, const char *name,
2811 int name_len);
2812struct btrfs_inode_extref *btrfs_find_name_in_ext_backref(
2813 struct extent_buffer *leaf, int slot, u64 ref_objectid,
2814 const char *name, int name_len);
2815
2816struct btrfs_dio_private;
2817int btrfs_del_csums(struct btrfs_trans_handle *trans,
2818 struct btrfs_root *root, u64 bytenr, u64 len);
2819blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
2820 u64 offset, u8 *dst);
2821int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
2822 struct btrfs_root *root,
2823 u64 objectid, u64 pos,
2824 u64 disk_offset, u64 disk_num_bytes,
2825 u64 num_bytes, u64 offset, u64 ram_bytes,
2826 u8 compression, u8 encryption, u16 other_encoding);
2827int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
2828 struct btrfs_root *root,
2829 struct btrfs_path *path, u64 objectid,
2830 u64 bytenr, int mod);
2831int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
2832 struct btrfs_root *root,
2833 struct btrfs_ordered_sum *sums);
2834blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
2835 u64 file_start, int contig);
2836int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
2837 struct list_head *list, int search_commit);
2838void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
2839 const struct btrfs_path *path,
2840 struct btrfs_file_extent_item *fi,
2841 const bool new_inline,
2842 struct extent_map *em);
2843int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
2844 u64 len);
2845int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
2846 u64 len);
2847void btrfs_inode_safe_disk_i_size_write(struct inode *inode, u64 new_i_size);
2848u64 btrfs_file_extent_end(const struct btrfs_path *path);
2849
2850
2851struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
2852 u64 start, u64 len);
2853noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
2854 u64 *orig_start, u64 *orig_block_len,
2855 u64 *ram_bytes);
2856
2857void __btrfs_del_delalloc_inode(struct btrfs_root *root,
2858 struct btrfs_inode *inode);
2859struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
2860int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
2861int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2862 struct btrfs_root *root,
2863 struct btrfs_inode *dir, struct btrfs_inode *inode,
2864 const char *name, int name_len);
2865int btrfs_add_link(struct btrfs_trans_handle *trans,
2866 struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
2867 const char *name, int name_len, int add_backref, u64 index);
2868int btrfs_delete_subvolume(struct inode *dir, struct dentry *dentry);
2869int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
2870 int front);
2871int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
2872 struct btrfs_root *root,
2873 struct inode *inode, u64 new_size,
2874 u32 min_type);
2875
2876int btrfs_start_delalloc_snapshot(struct btrfs_root *root);
2877int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int nr);
2878int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
2879 unsigned int extra_bits,
2880 struct extent_state **cached_state);
2881int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
2882 struct btrfs_root *new_root,
2883 struct btrfs_root *parent_root,
2884 u64 new_dirid);
2885 void btrfs_set_delalloc_extent(struct inode *inode, struct extent_state *state,
2886 unsigned *bits);
2887void btrfs_clear_delalloc_extent(struct inode *inode,
2888 struct extent_state *state, unsigned *bits);
2889void btrfs_merge_delalloc_extent(struct inode *inode, struct extent_state *new,
2890 struct extent_state *other);
2891void btrfs_split_delalloc_extent(struct inode *inode,
2892 struct extent_state *orig, u64 split);
2893int btrfs_bio_fits_in_stripe(struct page *page, size_t size, struct bio *bio,
2894 unsigned long bio_flags);
2895void btrfs_set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end);
2896vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
2897int btrfs_readpage(struct file *file, struct page *page);
2898void btrfs_evict_inode(struct inode *inode);
2899int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
2900struct inode *btrfs_alloc_inode(struct super_block *sb);
2901void btrfs_destroy_inode(struct inode *inode);
2902void btrfs_free_inode(struct inode *inode);
2903int btrfs_drop_inode(struct inode *inode);
2904int __init btrfs_init_cachep(void);
2905void __cold btrfs_destroy_cachep(void);
2906struct inode *btrfs_iget_path(struct super_block *s, u64 ino,
2907 struct btrfs_root *root, struct btrfs_path *path);
2908struct inode *btrfs_iget(struct super_block *s, u64 ino, struct btrfs_root *root);
2909struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
2910 struct page *page, size_t pg_offset,
2911 u64 start, u64 end);
2912int btrfs_update_inode(struct btrfs_trans_handle *trans,
2913 struct btrfs_root *root,
2914 struct inode *inode);
2915int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
2916 struct btrfs_root *root, struct inode *inode);
2917int btrfs_orphan_add(struct btrfs_trans_handle *trans,
2918 struct btrfs_inode *inode);
2919int btrfs_orphan_cleanup(struct btrfs_root *root);
2920int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
2921void btrfs_add_delayed_iput(struct inode *inode);
2922void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
2923int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);
2924int btrfs_prealloc_file_range(struct inode *inode, int mode,
2925 u64 start, u64 num_bytes, u64 min_size,
2926 loff_t actual_len, u64 *alloc_hint);
2927int btrfs_prealloc_file_range_trans(struct inode *inode,
2928 struct btrfs_trans_handle *trans, int mode,
2929 u64 start, u64 num_bytes, u64 min_size,
2930 loff_t actual_len, u64 *alloc_hint);
2931int btrfs_run_delalloc_range(struct inode *inode, struct page *locked_page,
2932 u64 start, u64 end, int *page_started, unsigned long *nr_written,
2933 struct writeback_control *wbc);
2934int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end);
2935void btrfs_writepage_endio_finish_ordered(struct page *page, u64 start,
2936 u64 end, int uptodate);
2937extern const struct dentry_operations btrfs_dentry_operations;
2938
2939
2940long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2941long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2942int btrfs_ioctl_get_supported_features(void __user *arg);
2943void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);
2944int __pure btrfs_is_empty_uuid(u8 *uuid);
2945int btrfs_defrag_file(struct inode *inode, struct file *file,
2946 struct btrfs_ioctl_defrag_range_args *range,
2947 u64 newer_than, unsigned long max_pages);
2948void btrfs_get_block_group_info(struct list_head *groups_list,
2949 struct btrfs_ioctl_space_info *space);
2950void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
2951 struct btrfs_ioctl_balance_args *bargs);
2952
2953
2954int __init btrfs_auto_defrag_init(void);
2955void __cold btrfs_auto_defrag_exit(void);
2956int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
2957 struct btrfs_inode *inode);
2958int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
2959void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
2960int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
2961void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
2962 int skip_pinned);
2963extern const struct file_operations btrfs_file_operations;
2964int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
2965 struct btrfs_root *root, struct inode *inode,
2966 struct btrfs_path *path, u64 start, u64 end,
2967 u64 *drop_end, int drop_cache,
2968 int replace_extent,
2969 u32 extent_item_size,
2970 int *key_inserted);
2971int btrfs_drop_extents(struct btrfs_trans_handle *trans,
2972 struct btrfs_root *root, struct inode *inode, u64 start,
2973 u64 end, int drop_cache);
2974int btrfs_punch_hole_range(struct inode *inode, struct btrfs_path *path,
2975 const u64 start, const u64 end,
2976 struct btrfs_clone_extent_info *clone_info,
2977 struct btrfs_trans_handle **trans_out);
2978int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
2979 struct btrfs_inode *inode, u64 start, u64 end);
2980int btrfs_release_file(struct inode *inode, struct file *file);
2981int btrfs_dirty_pages(struct inode *inode, struct page **pages,
2982 size_t num_pages, loff_t pos, size_t write_bytes,
2983 struct extent_state **cached);
2984int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
2985
2986
2987int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
2988 struct btrfs_root *root);
2989
2990
2991int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
2992 unsigned long new_flags);
2993int btrfs_sync_fs(struct super_block *sb, int wait);
2994char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
2995 u64 subvol_objectid);
2996
2997static inline __printf(2, 3) __cold
2998void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
2999{
3000}
3001
3002#ifdef CONFIG_PRINTK
3003__printf(2, 3)
3004__cold
3005void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3006#else
3007#define btrfs_printk(fs_info, fmt, args...) \
3008 btrfs_no_printk(fs_info, fmt, ##args)
3009#endif
3010
3011#define btrfs_emerg(fs_info, fmt, args...) \
3012 btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
3013#define btrfs_alert(fs_info, fmt, args...) \
3014 btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
3015#define btrfs_crit(fs_info, fmt, args...) \
3016 btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
3017#define btrfs_err(fs_info, fmt, args...) \
3018 btrfs_printk(fs_info, KERN_ERR fmt, ##args)
3019#define btrfs_warn(fs_info, fmt, args...) \
3020 btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
3021#define btrfs_notice(fs_info, fmt, args...) \
3022 btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
3023#define btrfs_info(fs_info, fmt, args...) \
3024 btrfs_printk(fs_info, KERN_INFO fmt, ##args)
3025
3026
3027
3028
3029#define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
3030 btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3031#define btrfs_alert_in_rcu(fs_info, fmt, args...) \
3032 btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3033#define btrfs_crit_in_rcu(fs_info, fmt, args...) \
3034 btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3035#define btrfs_err_in_rcu(fs_info, fmt, args...) \
3036 btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
3037#define btrfs_warn_in_rcu(fs_info, fmt, args...) \
3038 btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3039#define btrfs_notice_in_rcu(fs_info, fmt, args...) \
3040 btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3041#define btrfs_info_in_rcu(fs_info, fmt, args...) \
3042 btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)
3043
3044
3045
3046
3047#define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
3048 btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3049#define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
3050 btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3051#define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
3052 btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3053#define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
3054 btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
3055#define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
3056 btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3057#define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
3058 btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3059#define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
3060 btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)
3061
3062
3063
3064
3065#define btrfs_emerg_rl(fs_info, fmt, args...) \
3066 btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
3067#define btrfs_alert_rl(fs_info, fmt, args...) \
3068 btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
3069#define btrfs_crit_rl(fs_info, fmt, args...) \
3070 btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
3071#define btrfs_err_rl(fs_info, fmt, args...) \
3072 btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
3073#define btrfs_warn_rl(fs_info, fmt, args...) \
3074 btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
3075#define btrfs_notice_rl(fs_info, fmt, args...) \
3076 btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
3077#define btrfs_info_rl(fs_info, fmt, args...) \
3078 btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
3079
3080#if defined(CONFIG_DYNAMIC_DEBUG)
3081#define btrfs_debug(fs_info, fmt, args...) \
3082 _dynamic_func_call_no_desc(fmt, btrfs_printk, \
3083 fs_info, KERN_DEBUG fmt, ##args)
3084#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3085 _dynamic_func_call_no_desc(fmt, btrfs_printk_in_rcu, \
3086 fs_info, KERN_DEBUG fmt, ##args)
3087#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3088 _dynamic_func_call_no_desc(fmt, btrfs_printk_rl_in_rcu, \
3089 fs_info, KERN_DEBUG fmt, ##args)
3090#define btrfs_debug_rl(fs_info, fmt, args...) \
3091 _dynamic_func_call_no_desc(fmt, btrfs_printk_ratelimited, \
3092 fs_info, KERN_DEBUG fmt, ##args)
3093#elif defined(DEBUG)
3094#define btrfs_debug(fs_info, fmt, args...) \
3095 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3096#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3097 btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3098#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3099 btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3100#define btrfs_debug_rl(fs_info, fmt, args...) \
3101 btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
3102#else
3103#define btrfs_debug(fs_info, fmt, args...) \
3104 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3105#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3106 btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3107#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3108 btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3109#define btrfs_debug_rl(fs_info, fmt, args...) \
3110 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3111#endif
3112
3113#define btrfs_printk_in_rcu(fs_info, fmt, args...) \
3114do { \
3115 rcu_read_lock(); \
3116 btrfs_printk(fs_info, fmt, ##args); \
3117 rcu_read_unlock(); \
3118} while (0)
3119
3120#define btrfs_no_printk_in_rcu(fs_info, fmt, args...) \
3121do { \
3122 rcu_read_lock(); \
3123 btrfs_no_printk(fs_info, fmt, ##args); \
3124 rcu_read_unlock(); \
3125} while (0)
3126
3127#define btrfs_printk_ratelimited(fs_info, fmt, args...) \
3128do { \
3129 static DEFINE_RATELIMIT_STATE(_rs, \
3130 DEFAULT_RATELIMIT_INTERVAL, \
3131 DEFAULT_RATELIMIT_BURST); \
3132 if (__ratelimit(&_rs)) \
3133 btrfs_printk(fs_info, fmt, ##args); \
3134} while (0)
3135
3136#define btrfs_printk_rl_in_rcu(fs_info, fmt, args...) \
3137do { \
3138 rcu_read_lock(); \
3139 btrfs_printk_ratelimited(fs_info, fmt, ##args); \
3140 rcu_read_unlock(); \
3141} while (0)
3142
3143#ifdef CONFIG_BTRFS_ASSERT
3144__cold __noreturn
3145static inline void assertfail(const char *expr, const char *file, int line)
3146{
3147 pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
3148 BUG();
3149}
3150
3151#define ASSERT(expr) \
3152 (likely(expr) ? (void)0 : assertfail(#expr, __FILE__, __LINE__))
3153
3154#else
3155static inline void assertfail(const char *expr, const char* file, int line) { }
3156#define ASSERT(expr) (void)(expr)
3157#endif
3158
3159
3160
3161
3162
3163#ifndef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3164#define EXPORT_FOR_TESTS static
3165#else
3166#define EXPORT_FOR_TESTS
3167#endif
3168
3169__cold
3170static inline void btrfs_print_v0_err(struct btrfs_fs_info *fs_info)
3171{
3172 btrfs_err(fs_info,
3173"Unsupported V0 extent filesystem detected. Aborting. Please re-create your filesystem with a newer kernel");
3174}
3175
3176__printf(5, 6)
3177__cold
3178void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
3179 unsigned int line, int errno, const char *fmt, ...);
3180
3181const char * __attribute_const__ btrfs_decode_error(int errno);
3182
3183__cold
3184void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3185 const char *function,
3186 unsigned int line, int errno);
3187
3188
3189
3190
3191
3192#define btrfs_abort_transaction(trans, errno) \
3193do { \
3194 \
3195 if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED, \
3196 &((trans)->fs_info->fs_state))) { \
3197 if ((errno) != -EIO) { \
3198 WARN(1, KERN_DEBUG \
3199 "BTRFS: Transaction aborted (error %d)\n", \
3200 (errno)); \
3201 } else { \
3202 btrfs_debug((trans)->fs_info, \
3203 "Transaction aborted (error %d)", \
3204 (errno)); \
3205 } \
3206 } \
3207 __btrfs_abort_transaction((trans), __func__, \
3208 __LINE__, (errno)); \
3209} while (0)
3210
3211#define btrfs_handle_fs_error(fs_info, errno, fmt, args...) \
3212do { \
3213 __btrfs_handle_fs_error((fs_info), __func__, __LINE__, \
3214 (errno), fmt, ##args); \
3215} while (0)
3216
3217__printf(5, 6)
3218__cold
3219void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3220 unsigned int line, int errno, const char *fmt, ...);
3221
3222
3223
3224
3225#define btrfs_panic(fs_info, errno, fmt, args...) \
3226do { \
3227 __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \
3228 BUG(); \
3229} while (0)
3230
3231
3232
3233
3234#define btrfs_set_fs_incompat(__fs_info, opt) \
3235 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
3236 #opt)
3237
3238static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3239 u64 flag, const char* name)
3240{
3241 struct btrfs_super_block *disk_super;
3242 u64 features;
3243
3244 disk_super = fs_info->super_copy;
3245 features = btrfs_super_incompat_flags(disk_super);
3246 if (!(features & flag)) {
3247 spin_lock(&fs_info->super_lock);
3248 features = btrfs_super_incompat_flags(disk_super);
3249 if (!(features & flag)) {
3250 features |= flag;
3251 btrfs_set_super_incompat_flags(disk_super, features);
3252 btrfs_info(fs_info,
3253 "setting incompat feature flag for %s (0x%llx)",
3254 name, flag);
3255 }
3256 spin_unlock(&fs_info->super_lock);
3257 }
3258}
3259
3260#define btrfs_clear_fs_incompat(__fs_info, opt) \
3261 __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
3262 #opt)
3263
3264static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3265 u64 flag, const char* name)
3266{
3267 struct btrfs_super_block *disk_super;
3268 u64 features;
3269
3270 disk_super = fs_info->super_copy;
3271 features = btrfs_super_incompat_flags(disk_super);
3272 if (features & flag) {
3273 spin_lock(&fs_info->super_lock);
3274 features = btrfs_super_incompat_flags(disk_super);
3275 if (features & flag) {
3276 features &= ~flag;
3277 btrfs_set_super_incompat_flags(disk_super, features);
3278 btrfs_info(fs_info,
3279 "clearing incompat feature flag for %s (0x%llx)",
3280 name, flag);
3281 }
3282 spin_unlock(&fs_info->super_lock);
3283 }
3284}
3285
3286#define btrfs_fs_incompat(fs_info, opt) \
3287 __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3288
3289static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3290{
3291 struct btrfs_super_block *disk_super;
3292 disk_super = fs_info->super_copy;
3293 return !!(btrfs_super_incompat_flags(disk_super) & flag);
3294}
3295
3296#define btrfs_set_fs_compat_ro(__fs_info, opt) \
3297 __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
3298 #opt)
3299
3300static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3301 u64 flag, const char *name)
3302{
3303 struct btrfs_super_block *disk_super;
3304 u64 features;
3305
3306 disk_super = fs_info->super_copy;
3307 features = btrfs_super_compat_ro_flags(disk_super);
3308 if (!(features & flag)) {
3309 spin_lock(&fs_info->super_lock);
3310 features = btrfs_super_compat_ro_flags(disk_super);
3311 if (!(features & flag)) {
3312 features |= flag;
3313 btrfs_set_super_compat_ro_flags(disk_super, features);
3314 btrfs_info(fs_info,
3315 "setting compat-ro feature flag for %s (0x%llx)",
3316 name, flag);
3317 }
3318 spin_unlock(&fs_info->super_lock);
3319 }
3320}
3321
3322#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3323 __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
3324 #opt)
3325
3326static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3327 u64 flag, const char *name)
3328{
3329 struct btrfs_super_block *disk_super;
3330 u64 features;
3331
3332 disk_super = fs_info->super_copy;
3333 features = btrfs_super_compat_ro_flags(disk_super);
3334 if (features & flag) {
3335 spin_lock(&fs_info->super_lock);
3336 features = btrfs_super_compat_ro_flags(disk_super);
3337 if (features & flag) {
3338 features &= ~flag;
3339 btrfs_set_super_compat_ro_flags(disk_super, features);
3340 btrfs_info(fs_info,
3341 "clearing compat-ro feature flag for %s (0x%llx)",
3342 name, flag);
3343 }
3344 spin_unlock(&fs_info->super_lock);
3345 }
3346}
3347
3348#define btrfs_fs_compat_ro(fs_info, opt) \
3349 __btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3350
3351static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
3352{
3353 struct btrfs_super_block *disk_super;
3354 disk_super = fs_info->super_copy;
3355 return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
3356}
3357
3358
3359#ifdef CONFIG_BTRFS_FS_POSIX_ACL
3360struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3361int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
3362int btrfs_init_acl(struct btrfs_trans_handle *trans,
3363 struct inode *inode, struct inode *dir);
3364#else
3365#define btrfs_get_acl NULL
3366#define btrfs_set_acl NULL
3367static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
3368 struct inode *inode, struct inode *dir)
3369{
3370 return 0;
3371}
3372#endif
3373
3374
3375int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
3376int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3377 struct btrfs_root *root);
3378int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3379 struct btrfs_root *root);
3380int btrfs_recover_relocation(struct btrfs_root *root);
3381int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
3382int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3383 struct btrfs_root *root, struct extent_buffer *buf,
3384 struct extent_buffer *cow);
3385void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
3386 u64 *bytes_to_reserve);
3387int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3388 struct btrfs_pending_snapshot *pending);
3389int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);
3390struct btrfs_root *find_reloc_root(struct btrfs_fs_info *fs_info,
3391 u64 bytenr);
3392int btrfs_should_ignore_reloc_root(struct btrfs_root *root);
3393
3394
3395int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
3396 u64 end, struct btrfs_scrub_progress *progress,
3397 int readonly, int is_dev_replace);
3398void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3399void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3400int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3401int btrfs_scrub_cancel_dev(struct btrfs_device *dev);
3402int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
3403 struct btrfs_scrub_progress *progress);
3404static inline void btrfs_init_full_stripe_locks_tree(
3405 struct btrfs_full_stripe_locks_tree *locks_root)
3406{
3407 locks_root->root = RB_ROOT;
3408 mutex_init(&locks_root->lock);
3409}
3410
3411
3412void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
3413void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
3414void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);
3415
3416static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
3417{
3418 btrfs_bio_counter_sub(fs_info, 1);
3419}
3420
3421
3422struct reada_control {
3423 struct btrfs_fs_info *fs_info;
3424 struct btrfs_key key_start;
3425 struct btrfs_key key_end;
3426 atomic_t elems;
3427 struct kref refcnt;
3428 wait_queue_head_t wait;
3429};
3430struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3431 struct btrfs_key *start, struct btrfs_key *end);
3432int btrfs_reada_wait(void *handle);
3433void btrfs_reada_detach(void *handle);
3434int btree_readahead_hook(struct extent_buffer *eb, int err);
3435
3436static inline int is_fstree(u64 rootid)
3437{
3438 if (rootid == BTRFS_FS_TREE_OBJECTID ||
3439 ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
3440 !btrfs_qgroup_level(rootid)))
3441 return 1;
3442 return 0;
3443}
3444
3445static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
3446{
3447 return signal_pending(current);
3448}
3449
3450#define in_range(b, first, len) ((b) >= (first) && (b) < (first) + (len))
3451
3452
3453#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3454void btrfs_test_inode_set_ops(struct inode *inode);
3455void btrfs_test_destroy_inode(struct inode *inode);
3456
3457static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3458{
3459 return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
3460}
3461#else
3462static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3463{
3464 return 0;
3465}
3466#endif
3467
3468#endif
3469