1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#ifndef __BTRFS_CTREE__
20#define __BTRFS_CTREE__
21
22#include <linux/mm.h>
23#include <linux/highmem.h>
24#include <linux/fs.h>
25#include <linux/rwsem.h>
26#include <linux/completion.h>
27#include <linux/backing-dev.h>
28#include <linux/wait.h>
29#include <linux/slab.h>
30#include <linux/kobject.h>
31#include <trace/events/btrfs.h>
32#include <asm/kmap_types.h>
33#include <linux/pagemap.h>
34#include <linux/btrfs.h>
35#include "extent_io.h"
36#include "extent_map.h"
37#include "async-thread.h"
38
39struct btrfs_trans_handle;
40struct btrfs_transaction;
41struct btrfs_pending_snapshot;
42extern struct kmem_cache *btrfs_trans_handle_cachep;
43extern struct kmem_cache *btrfs_transaction_cachep;
44extern struct kmem_cache *btrfs_bit_radix_cachep;
45extern struct kmem_cache *btrfs_path_cachep;
46extern struct kmem_cache *btrfs_free_space_cachep;
47struct btrfs_ordered_sum;
48
49#define BTRFS_MAGIC 0x4D5F53665248425FULL
50
51#define BTRFS_MAX_MIRRORS 3
52
53#define BTRFS_MAX_LEVEL 8
54
55#define BTRFS_COMPAT_EXTENT_TREE_V0
56
57
58
59
60
61
62#define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
63
64
65#define BTRFS_ROOT_TREE_OBJECTID 1ULL
66
67
68#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
69
70
71
72
73
74#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
75
76
77
78
79
80#define BTRFS_DEV_TREE_OBJECTID 4ULL
81
82
83#define BTRFS_FS_TREE_OBJECTID 5ULL
84
85
86#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
87
88
89#define BTRFS_CSUM_TREE_OBJECTID 7ULL
90
91
92#define BTRFS_QUOTA_TREE_OBJECTID 8ULL
93
94
95#define BTRFS_BALANCE_OBJECTID -4ULL
96
97
98#define BTRFS_ORPHAN_OBJECTID -5ULL
99
100
101#define BTRFS_TREE_LOG_OBJECTID -6ULL
102#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
103
104
105#define BTRFS_TREE_RELOC_OBJECTID -8ULL
106#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
107
108
109
110
111
112
113#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
114
115
116#define BTRFS_FREE_SPACE_OBJECTID -11ULL
117
118
119
120
121
122#define BTRFS_FREE_INO_OBJECTID -12ULL
123
124
125#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
126
127
128
129
130#define BTRFS_FIRST_FREE_OBJECTID 256ULL
131#define BTRFS_LAST_FREE_OBJECTID -256ULL
132#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
133
134
135
136
137
138
139#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
140
141#define BTRFS_BTREE_INODE_OBJECTID 1
142
143#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
144
145#define BTRFS_DEV_REPLACE_DEVID 0
146
147
148
149
150
151#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
152
153
154
155
156
157#define BTRFS_NAME_LEN 255
158
159
160
161
162
163
164#define BTRFS_LINK_MAX 65535U
165
166
167#define BTRFS_CSUM_SIZE 32
168
169
170#define BTRFS_CSUM_TYPE_CRC32 0
171
172static int btrfs_csum_sizes[] = { 4, 0 };
173
174
175#define BTRFS_EMPTY_DIR_SIZE 0
176
177
178#define REQ_GET_READ_MIRRORS (1 << 30)
179
180#define BTRFS_FT_UNKNOWN 0
181#define BTRFS_FT_REG_FILE 1
182#define BTRFS_FT_DIR 2
183#define BTRFS_FT_CHRDEV 3
184#define BTRFS_FT_BLKDEV 4
185#define BTRFS_FT_FIFO 5
186#define BTRFS_FT_SOCK 6
187#define BTRFS_FT_SYMLINK 7
188#define BTRFS_FT_XATTR 8
189#define BTRFS_FT_MAX 9
190
191
192#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
193
194#define BTRFS_DIRTY_METADATA_THRESH (32 * 1024 * 1024)
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213struct btrfs_disk_key {
214 __le64 objectid;
215 u8 type;
216 __le64 offset;
217} __attribute__ ((__packed__));
218
219struct btrfs_key {
220 u64 objectid;
221 u8 type;
222 u64 offset;
223} __attribute__ ((__packed__));
224
225struct btrfs_mapping_tree {
226 struct extent_map_tree map_tree;
227};
228
229struct btrfs_dev_item {
230
231 __le64 devid;
232
233
234 __le64 total_bytes;
235
236
237 __le64 bytes_used;
238
239
240 __le32 io_align;
241
242
243 __le32 io_width;
244
245
246 __le32 sector_size;
247
248
249 __le64 type;
250
251
252 __le64 generation;
253
254
255
256
257
258 __le64 start_offset;
259
260
261 __le32 dev_group;
262
263
264 u8 seek_speed;
265
266
267 u8 bandwidth;
268
269
270 u8 uuid[BTRFS_UUID_SIZE];
271
272
273 u8 fsid[BTRFS_UUID_SIZE];
274} __attribute__ ((__packed__));
275
276struct btrfs_stripe {
277 __le64 devid;
278 __le64 offset;
279 u8 dev_uuid[BTRFS_UUID_SIZE];
280} __attribute__ ((__packed__));
281
282struct btrfs_chunk {
283
284 __le64 length;
285
286
287 __le64 owner;
288
289 __le64 stripe_len;
290 __le64 type;
291
292
293 __le32 io_align;
294
295
296 __le32 io_width;
297
298
299 __le32 sector_size;
300
301
302
303
304 __le16 num_stripes;
305
306
307 __le16 sub_stripes;
308 struct btrfs_stripe stripe;
309
310} __attribute__ ((__packed__));
311
312#define BTRFS_FREE_SPACE_EXTENT 1
313#define BTRFS_FREE_SPACE_BITMAP 2
314
315struct btrfs_free_space_entry {
316 __le64 offset;
317 __le64 bytes;
318 u8 type;
319} __attribute__ ((__packed__));
320
321struct btrfs_free_space_header {
322 struct btrfs_disk_key location;
323 __le64 generation;
324 __le64 num_entries;
325 __le64 num_bitmaps;
326} __attribute__ ((__packed__));
327
328static inline unsigned long btrfs_chunk_item_size(int num_stripes)
329{
330 BUG_ON(num_stripes == 0);
331 return sizeof(struct btrfs_chunk) +
332 sizeof(struct btrfs_stripe) * (num_stripes - 1);
333}
334
335#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
336#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
337
338
339
340
341#define BTRFS_FS_STATE_ERROR 0
342#define BTRFS_FS_STATE_REMOUNTING 1
343#define BTRFS_FS_STATE_TRANS_ABORTED 2
344
345
346
347#define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)
348
349#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
350#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
351
352#define BTRFS_BACKREF_REV_MAX 256
353#define BTRFS_BACKREF_REV_SHIFT 56
354#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
355 BTRFS_BACKREF_REV_SHIFT)
356
357#define BTRFS_OLD_BACKREF_REV 0
358#define BTRFS_MIXED_BACKREF_REV 1
359
360
361
362
363struct btrfs_header {
364
365 u8 csum[BTRFS_CSUM_SIZE];
366 u8 fsid[BTRFS_FSID_SIZE];
367 __le64 bytenr;
368 __le64 flags;
369
370
371 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
372 __le64 generation;
373 __le64 owner;
374 __le32 nritems;
375 u8 level;
376} __attribute__ ((__packed__));
377
378#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
379 sizeof(struct btrfs_header)) / \
380 sizeof(struct btrfs_key_ptr))
381#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
382#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
383#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
384 sizeof(struct btrfs_item) - \
385 sizeof(struct btrfs_file_extent_item))
386#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
387 sizeof(struct btrfs_item) -\
388 sizeof(struct btrfs_dir_item))
389
390
391
392
393
394
395#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
396#define BTRFS_LABEL_SIZE 256
397
398
399
400
401
402
403#define BTRFS_NUM_BACKUP_ROOTS 4
404struct btrfs_root_backup {
405 __le64 tree_root;
406 __le64 tree_root_gen;
407
408 __le64 chunk_root;
409 __le64 chunk_root_gen;
410
411 __le64 extent_root;
412 __le64 extent_root_gen;
413
414 __le64 fs_root;
415 __le64 fs_root_gen;
416
417 __le64 dev_root;
418 __le64 dev_root_gen;
419
420 __le64 csum_root;
421 __le64 csum_root_gen;
422
423 __le64 total_bytes;
424 __le64 bytes_used;
425 __le64 num_devices;
426
427 __le64 unused_64[4];
428
429 u8 tree_root_level;
430 u8 chunk_root_level;
431 u8 extent_root_level;
432 u8 fs_root_level;
433 u8 dev_root_level;
434 u8 csum_root_level;
435
436 u8 unused_8[10];
437} __attribute__ ((__packed__));
438
439
440
441
442
443struct btrfs_super_block {
444 u8 csum[BTRFS_CSUM_SIZE];
445
446 u8 fsid[BTRFS_FSID_SIZE];
447 __le64 bytenr;
448 __le64 flags;
449
450
451 __le64 magic;
452 __le64 generation;
453 __le64 root;
454 __le64 chunk_root;
455 __le64 log_root;
456
457
458 __le64 log_root_transid;
459 __le64 total_bytes;
460 __le64 bytes_used;
461 __le64 root_dir_objectid;
462 __le64 num_devices;
463 __le32 sectorsize;
464 __le32 nodesize;
465 __le32 leafsize;
466 __le32 stripesize;
467 __le32 sys_chunk_array_size;
468 __le64 chunk_root_generation;
469 __le64 compat_flags;
470 __le64 compat_ro_flags;
471 __le64 incompat_flags;
472 __le16 csum_type;
473 u8 root_level;
474 u8 chunk_root_level;
475 u8 log_root_level;
476 struct btrfs_dev_item dev_item;
477
478 char label[BTRFS_LABEL_SIZE];
479
480 __le64 cache_generation;
481
482
483 __le64 reserved[31];
484 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
485 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
486} __attribute__ ((__packed__));
487
488
489
490
491
492#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
493#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
494#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2)
495#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3)
496
497
498
499
500
501
502#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2 (1ULL << 4)
503
504
505
506
507
508#define BTRFS_FEATURE_INCOMPAT_BIG_METADATA (1ULL << 5)
509
510#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF (1ULL << 6)
511#define BTRFS_FEATURE_INCOMPAT_RAID56 (1ULL << 7)
512#define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA (1ULL << 8)
513
514#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
515#define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
516#define BTRFS_FEATURE_INCOMPAT_SUPP \
517 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
518 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
519 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
520 BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \
521 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \
522 BTRFS_FEATURE_INCOMPAT_RAID56 | \
523 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \
524 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
525
526
527
528
529
530struct btrfs_item {
531 struct btrfs_disk_key key;
532 __le32 offset;
533 __le32 size;
534} __attribute__ ((__packed__));
535
536
537
538
539
540
541
542
543struct btrfs_leaf {
544 struct btrfs_header header;
545 struct btrfs_item items[];
546} __attribute__ ((__packed__));
547
548
549
550
551
552struct btrfs_key_ptr {
553 struct btrfs_disk_key key;
554 __le64 blockptr;
555 __le64 generation;
556} __attribute__ ((__packed__));
557
558struct btrfs_node {
559 struct btrfs_header header;
560 struct btrfs_key_ptr ptrs[];
561} __attribute__ ((__packed__));
562
563
564
565
566
567
568
569
570
571struct btrfs_path {
572 struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
573 int slots[BTRFS_MAX_LEVEL];
574
575 int locks[BTRFS_MAX_LEVEL];
576 int reada;
577
578 int lowest_level;
579
580
581
582
583
584 unsigned int search_for_split:1;
585 unsigned int keep_locks:1;
586 unsigned int skip_locking:1;
587 unsigned int leave_spinning:1;
588 unsigned int search_commit_root:1;
589};
590
591
592
593
594
595
596struct btrfs_extent_item {
597 __le64 refs;
598 __le64 generation;
599 __le64 flags;
600} __attribute__ ((__packed__));
601
602struct btrfs_extent_item_v0 {
603 __le32 refs;
604} __attribute__ ((__packed__));
605
606#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
607 sizeof(struct btrfs_item))
608
609#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
610#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
611
612
613
614
615#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
616
617
618
619
620
621#define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)
622
623struct btrfs_tree_block_info {
624 struct btrfs_disk_key key;
625 u8 level;
626} __attribute__ ((__packed__));
627
628struct btrfs_extent_data_ref {
629 __le64 root;
630 __le64 objectid;
631 __le64 offset;
632 __le32 count;
633} __attribute__ ((__packed__));
634
635struct btrfs_shared_data_ref {
636 __le32 count;
637} __attribute__ ((__packed__));
638
639struct btrfs_extent_inline_ref {
640 u8 type;
641 __le64 offset;
642} __attribute__ ((__packed__));
643
644
645struct btrfs_extent_ref_v0 {
646 __le64 root;
647 __le64 generation;
648 __le64 objectid;
649 __le32 count;
650} __attribute__ ((__packed__));
651
652
653
654
655
656
657struct btrfs_dev_extent {
658 __le64 chunk_tree;
659 __le64 chunk_objectid;
660 __le64 chunk_offset;
661 __le64 length;
662 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
663} __attribute__ ((__packed__));
664
665struct btrfs_inode_ref {
666 __le64 index;
667 __le16 name_len;
668
669} __attribute__ ((__packed__));
670
671struct btrfs_inode_extref {
672 __le64 parent_objectid;
673 __le64 index;
674 __le16 name_len;
675 __u8 name[0];
676
677} __attribute__ ((__packed__));
678
679struct btrfs_timespec {
680 __le64 sec;
681 __le32 nsec;
682} __attribute__ ((__packed__));
683
684enum btrfs_compression_type {
685 BTRFS_COMPRESS_NONE = 0,
686 BTRFS_COMPRESS_ZLIB = 1,
687 BTRFS_COMPRESS_LZO = 2,
688 BTRFS_COMPRESS_TYPES = 2,
689 BTRFS_COMPRESS_LAST = 3,
690};
691
692struct btrfs_inode_item {
693
694 __le64 generation;
695
696 __le64 transid;
697 __le64 size;
698 __le64 nbytes;
699 __le64 block_group;
700 __le32 nlink;
701 __le32 uid;
702 __le32 gid;
703 __le32 mode;
704 __le64 rdev;
705 __le64 flags;
706
707
708 __le64 sequence;
709
710
711
712
713
714 __le64 reserved[4];
715 struct btrfs_timespec atime;
716 struct btrfs_timespec ctime;
717 struct btrfs_timespec mtime;
718 struct btrfs_timespec otime;
719} __attribute__ ((__packed__));
720
721struct btrfs_dir_log_item {
722 __le64 end;
723} __attribute__ ((__packed__));
724
725struct btrfs_dir_item {
726 struct btrfs_disk_key location;
727 __le64 transid;
728 __le16 data_len;
729 __le16 name_len;
730 u8 type;
731} __attribute__ ((__packed__));
732
733#define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)
734
735struct btrfs_root_item {
736 struct btrfs_inode_item inode;
737 __le64 generation;
738 __le64 root_dirid;
739 __le64 bytenr;
740 __le64 byte_limit;
741 __le64 bytes_used;
742 __le64 last_snapshot;
743 __le64 flags;
744 __le32 refs;
745 struct btrfs_disk_key drop_progress;
746 u8 drop_level;
747 u8 level;
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765 __le64 generation_v2;
766 u8 uuid[BTRFS_UUID_SIZE];
767 u8 parent_uuid[BTRFS_UUID_SIZE];
768 u8 received_uuid[BTRFS_UUID_SIZE];
769 __le64 ctransid;
770 __le64 otransid;
771 __le64 stransid;
772 __le64 rtransid;
773 struct btrfs_timespec ctime;
774 struct btrfs_timespec otime;
775 struct btrfs_timespec stime;
776 struct btrfs_timespec rtime;
777 __le64 reserved[8];
778} __attribute__ ((__packed__));
779
780
781
782
783struct btrfs_root_ref {
784 __le64 dirid;
785 __le64 sequence;
786 __le16 name_len;
787} __attribute__ ((__packed__));
788
789struct btrfs_disk_balance_args {
790
791
792
793
794 __le64 profiles;
795
796
797 __le64 usage;
798
799
800 __le64 devid;
801
802
803 __le64 pstart;
804 __le64 pend;
805
806
807 __le64 vstart;
808 __le64 vend;
809
810
811
812
813
814 __le64 target;
815
816
817 __le64 flags;
818
819 __le64 unused[8];
820} __attribute__ ((__packed__));
821
822
823
824
825
826struct btrfs_balance_item {
827
828 __le64 flags;
829
830 struct btrfs_disk_balance_args data;
831 struct btrfs_disk_balance_args meta;
832 struct btrfs_disk_balance_args sys;
833
834 __le64 unused[4];
835} __attribute__ ((__packed__));
836
837#define BTRFS_FILE_EXTENT_INLINE 0
838#define BTRFS_FILE_EXTENT_REG 1
839#define BTRFS_FILE_EXTENT_PREALLOC 2
840
841struct btrfs_file_extent_item {
842
843
844
845 __le64 generation;
846
847
848
849
850
851
852
853 __le64 ram_bytes;
854
855
856
857
858
859
860
861
862 u8 compression;
863 u8 encryption;
864 __le16 other_encoding;
865
866
867 u8 type;
868
869
870
871
872
873 __le64 disk_bytenr;
874 __le64 disk_num_bytes;
875
876
877
878
879
880
881
882 __le64 offset;
883
884
885
886
887 __le64 num_bytes;
888
889} __attribute__ ((__packed__));
890
891struct btrfs_csum_item {
892 u8 csum;
893} __attribute__ ((__packed__));
894
895struct btrfs_dev_stats_item {
896
897
898
899
900 __le64 values[BTRFS_DEV_STAT_VALUES_MAX];
901} __attribute__ ((__packed__));
902
903#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 0
904#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID 1
905#define BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED 0
906#define BTRFS_DEV_REPLACE_ITEM_STATE_STARTED 1
907#define BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED 2
908#define BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED 3
909#define BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED 4
910
911struct btrfs_dev_replace {
912 u64 replace_state;
913 u64 time_started;
914 u64 time_stopped;
915 atomic64_t num_write_errors;
916 atomic64_t num_uncorrectable_read_errors;
917
918 u64 cursor_left;
919 u64 committed_cursor_left;
920 u64 cursor_left_last_write_of_item;
921 u64 cursor_right;
922
923 u64 cont_reading_from_srcdev_mode;
924
925 int is_valid;
926 int item_needs_writeback;
927 struct btrfs_device *srcdev;
928 struct btrfs_device *tgtdev;
929
930 pid_t lock_owner;
931 atomic_t nesting_level;
932 struct mutex lock_finishing_cancel_unmount;
933 struct mutex lock_management_lock;
934 struct mutex lock;
935
936 struct btrfs_scrub_progress scrub_progress;
937};
938
939struct btrfs_dev_replace_item {
940
941
942
943
944 __le64 src_devid;
945 __le64 cursor_left;
946 __le64 cursor_right;
947 __le64 cont_reading_from_srcdev_mode;
948
949 __le64 replace_state;
950 __le64 time_started;
951 __le64 time_stopped;
952 __le64 num_write_errors;
953 __le64 num_uncorrectable_read_errors;
954} __attribute__ ((__packed__));
955
956
957#define BTRFS_BLOCK_GROUP_DATA (1ULL << 0)
958#define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1)
959#define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2)
960#define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3)
961#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)
962#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)
963#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
964#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)
965#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)
966#define BTRFS_BLOCK_GROUP_RESERVED BTRFS_AVAIL_ALLOC_BIT_SINGLE
967
968enum btrfs_raid_types {
969 BTRFS_RAID_RAID10,
970 BTRFS_RAID_RAID1,
971 BTRFS_RAID_DUP,
972 BTRFS_RAID_RAID0,
973 BTRFS_RAID_SINGLE,
974 BTRFS_RAID_RAID5,
975 BTRFS_RAID_RAID6,
976 BTRFS_NR_RAID_TYPES
977};
978
979#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \
980 BTRFS_BLOCK_GROUP_SYSTEM | \
981 BTRFS_BLOCK_GROUP_METADATA)
982
983#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \
984 BTRFS_BLOCK_GROUP_RAID1 | \
985 BTRFS_BLOCK_GROUP_RAID5 | \
986 BTRFS_BLOCK_GROUP_RAID6 | \
987 BTRFS_BLOCK_GROUP_DUP | \
988 BTRFS_BLOCK_GROUP_RAID10)
989
990
991
992
993
994
995
996#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)
997
998#define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK | \
999 BTRFS_AVAIL_ALLOC_BIT_SINGLE)
1000
1001static inline u64 chunk_to_extended(u64 flags)
1002{
1003 if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)
1004 flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1005
1006 return flags;
1007}
1008static inline u64 extended_to_chunk(u64 flags)
1009{
1010 return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1011}
1012
1013struct btrfs_block_group_item {
1014 __le64 used;
1015 __le64 chunk_objectid;
1016 __le64 flags;
1017} __attribute__ ((__packed__));
1018
1019
1020
1021
1022#define BTRFS_QGROUP_STATUS_FLAG_ON (1ULL << 0)
1023
1024
1025
1026#define BTRFS_QGROUP_STATUS_FLAG_RESCAN (1ULL << 1)
1027
1028
1029
1030
1031
1032
1033
1034#define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT (1ULL << 2)
1035
1036#define BTRFS_QGROUP_STATUS_VERSION 1
1037
1038struct btrfs_qgroup_status_item {
1039 __le64 version;
1040
1041
1042
1043
1044
1045
1046 __le64 generation;
1047
1048
1049 __le64 flags;
1050
1051
1052
1053
1054
1055 __le64 rescan;
1056} __attribute__ ((__packed__));
1057
1058struct btrfs_qgroup_info_item {
1059 __le64 generation;
1060 __le64 rfer;
1061 __le64 rfer_cmpr;
1062 __le64 excl;
1063 __le64 excl_cmpr;
1064} __attribute__ ((__packed__));
1065
1066
1067#define BTRFS_QGROUP_LIMIT_MAX_RFER (1ULL << 0)
1068#define BTRFS_QGROUP_LIMIT_MAX_EXCL (1ULL << 1)
1069#define BTRFS_QGROUP_LIMIT_RSV_RFER (1ULL << 2)
1070#define BTRFS_QGROUP_LIMIT_RSV_EXCL (1ULL << 3)
1071#define BTRFS_QGROUP_LIMIT_RFER_CMPR (1ULL << 4)
1072#define BTRFS_QGROUP_LIMIT_EXCL_CMPR (1ULL << 5)
1073
1074struct btrfs_qgroup_limit_item {
1075
1076
1077
1078 __le64 flags;
1079 __le64 max_rfer;
1080 __le64 max_excl;
1081 __le64 rsv_rfer;
1082 __le64 rsv_excl;
1083} __attribute__ ((__packed__));
1084
1085struct btrfs_space_info {
1086 u64 flags;
1087
1088 u64 total_bytes;
1089
1090 u64 bytes_used;
1091
1092 u64 bytes_pinned;
1093
1094 u64 bytes_reserved;
1095
1096 u64 bytes_readonly;
1097
1098 u64 bytes_may_use;
1099
1100 u64 disk_used;
1101 u64 disk_total;
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114 struct percpu_counter total_bytes_pinned;
1115
1116
1117
1118
1119
1120
1121
1122
1123 unsigned long reservation_progress;
1124
1125 unsigned int full:1;
1126
1127 unsigned int chunk_alloc:1;
1128
1129 unsigned int flush:1;
1130
1131 unsigned int force_alloc;
1132
1133
1134 struct list_head list;
1135
1136
1137 struct list_head block_groups[BTRFS_NR_RAID_TYPES];
1138 spinlock_t lock;
1139 struct rw_semaphore groups_sem;
1140 wait_queue_head_t wait;
1141};
1142
1143#define BTRFS_BLOCK_RSV_GLOBAL 1
1144#define BTRFS_BLOCK_RSV_DELALLOC 2
1145#define BTRFS_BLOCK_RSV_TRANS 3
1146#define BTRFS_BLOCK_RSV_CHUNK 4
1147#define BTRFS_BLOCK_RSV_DELOPS 5
1148#define BTRFS_BLOCK_RSV_EMPTY 6
1149#define BTRFS_BLOCK_RSV_TEMP 7
1150
1151struct btrfs_block_rsv {
1152 u64 size;
1153 u64 reserved;
1154 struct btrfs_space_info *space_info;
1155 spinlock_t lock;
1156 unsigned short full;
1157 unsigned short type;
1158 unsigned short failfast;
1159};
1160
1161
1162
1163
1164
1165
1166struct btrfs_free_cluster {
1167 spinlock_t lock;
1168 spinlock_t refill_lock;
1169 struct rb_root root;
1170
1171
1172 u64 max_size;
1173
1174
1175 u64 window_start;
1176
1177 struct btrfs_block_group_cache *block_group;
1178
1179
1180
1181
1182
1183 struct list_head block_group_list;
1184};
1185
1186enum btrfs_caching_type {
1187 BTRFS_CACHE_NO = 0,
1188 BTRFS_CACHE_STARTED = 1,
1189 BTRFS_CACHE_FAST = 2,
1190 BTRFS_CACHE_FINISHED = 3,
1191};
1192
1193enum btrfs_disk_cache_state {
1194 BTRFS_DC_WRITTEN = 0,
1195 BTRFS_DC_ERROR = 1,
1196 BTRFS_DC_CLEAR = 2,
1197 BTRFS_DC_SETUP = 3,
1198 BTRFS_DC_NEED_WRITE = 4,
1199};
1200
1201struct btrfs_caching_control {
1202 struct list_head list;
1203 struct mutex mutex;
1204 wait_queue_head_t wait;
1205 struct btrfs_work work;
1206 struct btrfs_block_group_cache *block_group;
1207 u64 progress;
1208 atomic_t count;
1209};
1210
1211struct btrfs_block_group_cache {
1212 struct btrfs_key key;
1213 struct btrfs_block_group_item item;
1214 struct btrfs_fs_info *fs_info;
1215 struct inode *inode;
1216 spinlock_t lock;
1217 u64 pinned;
1218 u64 reserved;
1219 u64 bytes_super;
1220 u64 flags;
1221 u64 sectorsize;
1222 u64 cache_generation;
1223
1224
1225 unsigned long full_stripe_len;
1226
1227 unsigned int ro:1;
1228 unsigned int dirty:1;
1229 unsigned int iref:1;
1230
1231 int disk_cache_state;
1232
1233
1234 int cached;
1235 struct btrfs_caching_control *caching_ctl;
1236 u64 last_byte_to_unpin;
1237
1238 struct btrfs_space_info *space_info;
1239
1240
1241 struct btrfs_free_space_ctl *free_space_ctl;
1242
1243
1244 struct rb_node cache_node;
1245
1246
1247 struct list_head list;
1248
1249
1250 atomic_t count;
1251
1252
1253
1254
1255 struct list_head cluster_list;
1256
1257
1258 struct list_head new_bg_list;
1259};
1260
1261
1262struct seq_list {
1263 struct list_head list;
1264 u64 seq;
1265};
1266
1267enum btrfs_orphan_cleanup_state {
1268 ORPHAN_CLEANUP_STARTED = 1,
1269 ORPHAN_CLEANUP_DONE = 2,
1270};
1271
1272
1273struct btrfs_stripe_hash {
1274 struct list_head hash_list;
1275 wait_queue_head_t wait;
1276 spinlock_t lock;
1277};
1278
1279
1280struct btrfs_stripe_hash_table {
1281 struct list_head stripe_cache;
1282 spinlock_t cache_lock;
1283 int cache_size;
1284 struct btrfs_stripe_hash table[];
1285};
1286
1287#define BTRFS_STRIPE_HASH_TABLE_BITS 11
1288
1289
1290struct reloc_control;
1291struct btrfs_device;
1292struct btrfs_fs_devices;
1293struct btrfs_balance_control;
1294struct btrfs_delayed_root;
1295struct btrfs_fs_info {
1296 u8 fsid[BTRFS_FSID_SIZE];
1297 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
1298 struct btrfs_root *extent_root;
1299 struct btrfs_root *tree_root;
1300 struct btrfs_root *chunk_root;
1301 struct btrfs_root *dev_root;
1302 struct btrfs_root *fs_root;
1303 struct btrfs_root *csum_root;
1304 struct btrfs_root *quota_root;
1305
1306
1307 struct btrfs_root *log_root_tree;
1308
1309 spinlock_t fs_roots_radix_lock;
1310 struct radix_tree_root fs_roots_radix;
1311
1312
1313 spinlock_t block_group_cache_lock;
1314 u64 first_logical_byte;
1315 struct rb_root block_group_cache_tree;
1316
1317
1318 spinlock_t free_chunk_lock;
1319 u64 free_chunk_space;
1320
1321 struct extent_io_tree freed_extents[2];
1322 struct extent_io_tree *pinned_extents;
1323
1324
1325 struct btrfs_mapping_tree mapping_tree;
1326
1327
1328
1329
1330
1331 struct btrfs_block_rsv global_block_rsv;
1332
1333 struct btrfs_block_rsv delalloc_block_rsv;
1334
1335 struct btrfs_block_rsv trans_block_rsv;
1336
1337 struct btrfs_block_rsv chunk_block_rsv;
1338
1339 struct btrfs_block_rsv delayed_block_rsv;
1340
1341 struct btrfs_block_rsv empty_block_rsv;
1342
1343 u64 generation;
1344 u64 last_trans_committed;
1345
1346
1347
1348
1349
1350 u64 last_trans_log_full_commit;
1351 unsigned long mount_opt;
1352 unsigned long compress_type:4;
1353
1354
1355
1356
1357
1358
1359 u64 max_inline;
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370 u64 alloc_start;
1371 struct btrfs_transaction *running_transaction;
1372 wait_queue_head_t transaction_throttle;
1373 wait_queue_head_t transaction_wait;
1374 wait_queue_head_t transaction_blocked_wait;
1375 wait_queue_head_t async_submit_wait;
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387 spinlock_t super_lock;
1388 struct btrfs_super_block *super_copy;
1389 struct btrfs_super_block *super_for_commit;
1390 struct block_device *__bdev;
1391 struct super_block *sb;
1392 struct inode *btree_inode;
1393 struct backing_dev_info bdi;
1394 struct mutex tree_log_mutex;
1395 struct mutex transaction_kthread_mutex;
1396 struct mutex cleaner_mutex;
1397 struct mutex chunk_mutex;
1398 struct mutex volume_mutex;
1399
1400
1401
1402
1403
1404 struct btrfs_stripe_hash_table *stripe_hash_table;
1405
1406
1407
1408
1409
1410
1411
1412
1413 struct mutex ordered_operations_mutex;
1414 struct rw_semaphore extent_commit_sem;
1415
1416 struct rw_semaphore cleanup_work_sem;
1417
1418 struct rw_semaphore subvol_sem;
1419 struct srcu_struct subvol_srcu;
1420
1421 spinlock_t trans_lock;
1422
1423
1424
1425
1426 struct mutex reloc_mutex;
1427
1428 struct list_head trans_list;
1429 struct list_head dead_roots;
1430 struct list_head caching_block_groups;
1431
1432 spinlock_t delayed_iput_lock;
1433 struct list_head delayed_iputs;
1434
1435
1436 spinlock_t tree_mod_seq_lock;
1437 atomic64_t tree_mod_seq;
1438 struct list_head tree_mod_seq_list;
1439 struct seq_list tree_mod_seq_elem;
1440
1441
1442 rwlock_t tree_mod_log_lock;
1443 struct rb_root tree_mod_log;
1444
1445 atomic_t nr_async_submits;
1446 atomic_t async_submit_draining;
1447 atomic_t nr_async_bios;
1448 atomic_t async_delalloc_pages;
1449 atomic_t open_ioctl_trans;
1450
1451
1452
1453
1454 spinlock_t ordered_root_lock;
1455
1456
1457
1458
1459
1460
1461
1462
1463 struct list_head ordered_roots;
1464
1465 spinlock_t delalloc_root_lock;
1466
1467 struct list_head delalloc_roots;
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479 struct btrfs_workers generic_worker;
1480 struct btrfs_workers workers;
1481 struct btrfs_workers delalloc_workers;
1482 struct btrfs_workers flush_workers;
1483 struct btrfs_workers endio_workers;
1484 struct btrfs_workers endio_meta_workers;
1485 struct btrfs_workers endio_raid56_workers;
1486 struct btrfs_workers rmw_workers;
1487 struct btrfs_workers endio_meta_write_workers;
1488 struct btrfs_workers endio_write_workers;
1489 struct btrfs_workers endio_freespace_worker;
1490 struct btrfs_workers submit_workers;
1491 struct btrfs_workers caching_workers;
1492 struct btrfs_workers readahead_workers;
1493
1494
1495
1496
1497
1498
1499 struct btrfs_workers fixup_workers;
1500 struct btrfs_workers delayed_workers;
1501 struct task_struct *transaction_kthread;
1502 struct task_struct *cleaner_kthread;
1503 int thread_pool_size;
1504
1505 struct kobject super_kobj;
1506 struct completion kobj_unregister;
1507 int do_barriers;
1508 int closing;
1509 int log_root_recovering;
1510
1511 u64 total_pinned;
1512
1513
1514 struct percpu_counter dirty_metadata_bytes;
1515 struct percpu_counter delalloc_bytes;
1516 s32 dirty_metadata_batch;
1517 s32 delalloc_batch;
1518
1519 struct list_head dirty_cowonly_roots;
1520
1521 struct btrfs_fs_devices *fs_devices;
1522
1523
1524
1525
1526
1527
1528 struct list_head space_info;
1529
1530 struct btrfs_space_info *data_sinfo;
1531
1532 struct reloc_control *reloc_ctl;
1533
1534
1535 struct btrfs_free_cluster data_alloc_cluster;
1536
1537
1538 struct btrfs_free_cluster meta_alloc_cluster;
1539
1540
1541 spinlock_t defrag_inodes_lock;
1542 struct rb_root defrag_inodes;
1543 atomic_t defrag_running;
1544
1545
1546 seqlock_t profiles_lock;
1547
1548
1549
1550
1551
1552 u64 avail_data_alloc_bits;
1553 u64 avail_metadata_alloc_bits;
1554 u64 avail_system_alloc_bits;
1555
1556
1557 spinlock_t balance_lock;
1558 struct mutex balance_mutex;
1559 atomic_t balance_running;
1560 atomic_t balance_pause_req;
1561 atomic_t balance_cancel_req;
1562 struct btrfs_balance_control *balance_ctl;
1563 wait_queue_head_t balance_wait_q;
1564
1565 unsigned data_chunk_allocations;
1566 unsigned metadata_ratio;
1567
1568 void *bdev_holder;
1569
1570
1571 struct mutex scrub_lock;
1572 atomic_t scrubs_running;
1573 atomic_t scrub_pause_req;
1574 atomic_t scrubs_paused;
1575 atomic_t scrub_cancel_req;
1576 wait_queue_head_t scrub_pause_wait;
1577 struct rw_semaphore scrub_super_lock;
1578 int scrub_workers_refcnt;
1579 struct btrfs_workers scrub_workers;
1580 struct btrfs_workers scrub_wr_completion_workers;
1581 struct btrfs_workers scrub_nocow_workers;
1582
1583#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1584 u32 check_integrity_print_mask;
1585#endif
1586
1587
1588
1589 unsigned int quota_enabled:1;
1590
1591
1592
1593
1594
1595 unsigned int pending_quota_state:1;
1596
1597
1598 u64 qgroup_flags;
1599
1600
1601 struct rb_root qgroup_tree;
1602 spinlock_t qgroup_lock;
1603
1604
1605
1606
1607
1608 struct ulist *qgroup_ulist;
1609
1610
1611 struct mutex qgroup_ioctl_lock;
1612
1613
1614 struct list_head dirty_qgroups;
1615
1616
1617 u64 qgroup_seq;
1618
1619
1620 struct mutex qgroup_rescan_lock;
1621 struct btrfs_key qgroup_rescan_progress;
1622 struct btrfs_workers qgroup_rescan_workers;
1623 struct completion qgroup_rescan_completion;
1624 struct btrfs_work qgroup_rescan_work;
1625
1626
1627 unsigned long fs_state;
1628
1629 struct btrfs_delayed_root *delayed_root;
1630
1631
1632 spinlock_t reada_lock;
1633 struct radix_tree_root reada_tree;
1634
1635
1636 int backup_root_index;
1637
1638 int num_tolerated_disk_barrier_failures;
1639
1640
1641 struct btrfs_dev_replace dev_replace;
1642
1643 atomic_t mutually_exclusive_operation_running;
1644};
1645
1646
1647
1648
1649
1650struct btrfs_root {
1651 struct extent_buffer *node;
1652
1653 struct extent_buffer *commit_root;
1654 struct btrfs_root *log_root;
1655 struct btrfs_root *reloc_root;
1656
1657 struct btrfs_root_item root_item;
1658 struct btrfs_key root_key;
1659 struct btrfs_fs_info *fs_info;
1660 struct extent_io_tree dirty_log_pages;
1661
1662 struct kobject root_kobj;
1663 struct completion kobj_unregister;
1664 struct mutex objectid_mutex;
1665
1666 spinlock_t accounting_lock;
1667 struct btrfs_block_rsv *block_rsv;
1668
1669
1670 struct mutex fs_commit_mutex;
1671 struct btrfs_free_space_ctl *free_ino_ctl;
1672 enum btrfs_caching_type cached;
1673 spinlock_t cache_lock;
1674 wait_queue_head_t cache_wait;
1675 struct btrfs_free_space_ctl *free_ino_pinned;
1676 u64 cache_progress;
1677 struct inode *cache_inode;
1678
1679 struct mutex log_mutex;
1680 wait_queue_head_t log_writer_wait;
1681 wait_queue_head_t log_commit_wait[2];
1682 atomic_t log_writers;
1683 atomic_t log_commit[2];
1684 atomic_t log_batch;
1685 unsigned long log_transid;
1686 unsigned long last_log_commit;
1687 pid_t log_start_pid;
1688 bool log_multiple_pids;
1689
1690 u64 objectid;
1691 u64 last_trans;
1692
1693
1694 u32 sectorsize;
1695
1696
1697 u32 nodesize;
1698
1699
1700 u32 leafsize;
1701
1702 u32 stripesize;
1703
1704 u32 type;
1705
1706 u64 highest_objectid;
1707
1708
1709
1710
1711
1712
1713
1714 unsigned long in_trans_setup;
1715 int ref_cows;
1716 int track_dirty;
1717 int in_radix;
1718
1719 u64 defrag_trans_start;
1720 struct btrfs_key defrag_progress;
1721 struct btrfs_key defrag_max;
1722 int defrag_running;
1723 char *name;
1724
1725
1726 struct list_head dirty_list;
1727
1728 struct list_head root_list;
1729
1730 spinlock_t log_extents_lock[2];
1731 struct list_head logged_list[2];
1732
1733 spinlock_t orphan_lock;
1734 atomic_t orphan_inodes;
1735 struct btrfs_block_rsv *orphan_block_rsv;
1736 int orphan_item_inserted;
1737 int orphan_cleanup_state;
1738
1739 spinlock_t inode_lock;
1740
1741 struct rb_root inode_tree;
1742
1743
1744
1745
1746
1747 struct radix_tree_root delayed_nodes_tree;
1748
1749
1750
1751
1752 dev_t anon_dev;
1753
1754 int force_cow;
1755
1756 spinlock_t root_item_lock;
1757 atomic_t refs;
1758
1759 spinlock_t delalloc_lock;
1760
1761
1762
1763
1764
1765 struct list_head delalloc_inodes;
1766 struct list_head delalloc_root;
1767 u64 nr_delalloc_inodes;
1768
1769
1770
1771
1772 spinlock_t ordered_extent_lock;
1773
1774
1775
1776
1777
1778
1779 struct list_head ordered_extents;
1780 struct list_head ordered_root;
1781 u64 nr_ordered_extents;
1782};
1783
1784struct btrfs_ioctl_defrag_range_args {
1785
1786 __u64 start;
1787
1788
1789 __u64 len;
1790
1791
1792
1793
1794
1795 __u64 flags;
1796
1797
1798
1799
1800
1801
1802 __u32 extent_thresh;
1803
1804
1805
1806
1807
1808
1809 __u32 compress_type;
1810
1811
1812 __u32 unused[4];
1813};
1814
1815
1816
1817
1818
1819
1820
1821#define BTRFS_INODE_ITEM_KEY 1
1822#define BTRFS_INODE_REF_KEY 12
1823#define BTRFS_INODE_EXTREF_KEY 13
1824#define BTRFS_XATTR_ITEM_KEY 24
1825#define BTRFS_ORPHAN_ITEM_KEY 48
1826
1827
1828
1829
1830
1831
1832#define BTRFS_DIR_LOG_ITEM_KEY 60
1833#define BTRFS_DIR_LOG_INDEX_KEY 72
1834#define BTRFS_DIR_ITEM_KEY 84
1835#define BTRFS_DIR_INDEX_KEY 96
1836
1837
1838
1839#define BTRFS_EXTENT_DATA_KEY 108
1840
1841
1842
1843
1844
1845#define BTRFS_EXTENT_CSUM_KEY 128
1846
1847
1848
1849
1850
1851#define BTRFS_ROOT_ITEM_KEY 132
1852
1853
1854
1855
1856
1857#define BTRFS_ROOT_BACKREF_KEY 144
1858
1859
1860
1861
1862
1863
1864#define BTRFS_ROOT_REF_KEY 156
1865
1866
1867
1868
1869
1870#define BTRFS_EXTENT_ITEM_KEY 168
1871
1872
1873
1874
1875
1876#define BTRFS_METADATA_ITEM_KEY 169
1877
1878#define BTRFS_TREE_BLOCK_REF_KEY 176
1879
1880#define BTRFS_EXTENT_DATA_REF_KEY 178
1881
1882#define BTRFS_EXTENT_REF_V0_KEY 180
1883
1884#define BTRFS_SHARED_BLOCK_REF_KEY 182
1885
1886#define BTRFS_SHARED_DATA_REF_KEY 184
1887
1888
1889
1890
1891
1892#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
1893
1894#define BTRFS_DEV_EXTENT_KEY 204
1895#define BTRFS_DEV_ITEM_KEY 216
1896#define BTRFS_CHUNK_ITEM_KEY 228
1897
1898
1899
1900
1901
1902
1903#define BTRFS_QGROUP_STATUS_KEY 240
1904
1905
1906
1907
1908#define BTRFS_QGROUP_INFO_KEY 242
1909
1910
1911
1912
1913#define BTRFS_QGROUP_LIMIT_KEY 244
1914
1915
1916
1917
1918
1919
1920#define BTRFS_QGROUP_RELATION_KEY 246
1921
1922#define BTRFS_BALANCE_ITEM_KEY 248
1923
1924
1925
1926
1927
1928#define BTRFS_DEV_STATS_KEY 249
1929
1930
1931
1932
1933
1934#define BTRFS_DEV_REPLACE_KEY 250
1935
1936
1937
1938
1939
1940#define BTRFS_STRING_ITEM_KEY 253
1941
1942
1943
1944
1945
1946
1947#define BTRFS_MOUNT_NODATASUM (1 << 0)
1948#define BTRFS_MOUNT_NODATACOW (1 << 1)
1949#define BTRFS_MOUNT_NOBARRIER (1 << 2)
1950#define BTRFS_MOUNT_SSD (1 << 3)
1951#define BTRFS_MOUNT_DEGRADED (1 << 4)
1952#define BTRFS_MOUNT_COMPRESS (1 << 5)
1953#define BTRFS_MOUNT_NOTREELOG (1 << 6)
1954#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
1955#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
1956#define BTRFS_MOUNT_NOSSD (1 << 9)
1957#define BTRFS_MOUNT_DISCARD (1 << 10)
1958#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
1959#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
1960#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
1961#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
1962#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
1963#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
1964#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
1965#define BTRFS_MOUNT_RECOVERY (1 << 18)
1966#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
1967#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
1968#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
1969#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22)
1970
1971#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
1972#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
1973#define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt)
1974#define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \
1975 BTRFS_MOUNT_##opt)
1976
1977
1978
1979#define BTRFS_INODE_NODATASUM (1 << 0)
1980#define BTRFS_INODE_NODATACOW (1 << 1)
1981#define BTRFS_INODE_READONLY (1 << 2)
1982#define BTRFS_INODE_NOCOMPRESS (1 << 3)
1983#define BTRFS_INODE_PREALLOC (1 << 4)
1984#define BTRFS_INODE_SYNC (1 << 5)
1985#define BTRFS_INODE_IMMUTABLE (1 << 6)
1986#define BTRFS_INODE_APPEND (1 << 7)
1987#define BTRFS_INODE_NODUMP (1 << 8)
1988#define BTRFS_INODE_NOATIME (1 << 9)
1989#define BTRFS_INODE_DIRSYNC (1 << 10)
1990#define BTRFS_INODE_COMPRESS (1 << 11)
1991
1992#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
1993
1994struct btrfs_map_token {
1995 struct extent_buffer *eb;
1996 char *kaddr;
1997 unsigned long offset;
1998};
1999
2000static inline void btrfs_init_map_token (struct btrfs_map_token *token)
2001{
2002 token->kaddr = NULL;
2003}
2004
2005
2006
2007
2008
2009#define le8_to_cpu(v) (v)
2010#define cpu_to_le8(v) (v)
2011#define __le8 u8
2012
2013#define read_eb_member(eb, ptr, type, member, result) ( \
2014 read_extent_buffer(eb, (char *)(result), \
2015 ((unsigned long)(ptr)) + \
2016 offsetof(type, member), \
2017 sizeof(((type *)0)->member)))
2018
2019#define write_eb_member(eb, ptr, type, member, result) ( \
2020 write_extent_buffer(eb, (char *)(result), \
2021 ((unsigned long)(ptr)) + \
2022 offsetof(type, member), \
2023 sizeof(((type *)0)->member)))
2024
2025#define DECLARE_BTRFS_SETGET_BITS(bits) \
2026u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr, \
2027 unsigned long off, \
2028 struct btrfs_map_token *token); \
2029void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr, \
2030 unsigned long off, u##bits val, \
2031 struct btrfs_map_token *token); \
2032static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \
2033 unsigned long off) \
2034{ \
2035 return btrfs_get_token_##bits(eb, ptr, off, NULL); \
2036} \
2037static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \
2038 unsigned long off, u##bits val) \
2039{ \
2040 btrfs_set_token_##bits(eb, ptr, off, val, NULL); \
2041}
2042
2043DECLARE_BTRFS_SETGET_BITS(8)
2044DECLARE_BTRFS_SETGET_BITS(16)
2045DECLARE_BTRFS_SETGET_BITS(32)
2046DECLARE_BTRFS_SETGET_BITS(64)
2047
2048#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
2049static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s) \
2050{ \
2051 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2052 return btrfs_get_##bits(eb, s, offsetof(type, member)); \
2053} \
2054static inline void btrfs_set_##name(struct extent_buffer *eb, type *s, \
2055 u##bits val) \
2056{ \
2057 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2058 btrfs_set_##bits(eb, s, offsetof(type, member), val); \
2059} \
2060static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \
2061 struct btrfs_map_token *token) \
2062{ \
2063 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2064 return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
2065} \
2066static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
2067 type *s, u##bits val, \
2068 struct btrfs_map_token *token) \
2069{ \
2070 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2071 btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
2072}
2073
2074#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
2075static inline u##bits btrfs_##name(struct extent_buffer *eb) \
2076{ \
2077 type *p = page_address(eb->pages[0]); \
2078 u##bits res = le##bits##_to_cpu(p->member); \
2079 return res; \
2080} \
2081static inline void btrfs_set_##name(struct extent_buffer *eb, \
2082 u##bits val) \
2083{ \
2084 type *p = page_address(eb->pages[0]); \
2085 p->member = cpu_to_le##bits(val); \
2086}
2087
2088#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
2089static inline u##bits btrfs_##name(type *s) \
2090{ \
2091 return le##bits##_to_cpu(s->member); \
2092} \
2093static inline void btrfs_set_##name(type *s, u##bits val) \
2094{ \
2095 s->member = cpu_to_le##bits(val); \
2096}
2097
2098BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
2099BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
2100BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
2101BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
2102BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
2103BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
2104 start_offset, 64);
2105BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
2106BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
2107BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
2108BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
2109BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
2110BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
2111
2112BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
2113BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
2114 total_bytes, 64);
2115BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
2116 bytes_used, 64);
2117BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
2118 io_align, 32);
2119BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
2120 io_width, 32);
2121BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
2122 sector_size, 32);
2123BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
2124BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
2125 dev_group, 32);
2126BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
2127 seek_speed, 8);
2128BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
2129 bandwidth, 8);
2130BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
2131 generation, 64);
2132
2133static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
2134{
2135 return (char *)d + offsetof(struct btrfs_dev_item, uuid);
2136}
2137
2138static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
2139{
2140 return (char *)d + offsetof(struct btrfs_dev_item, fsid);
2141}
2142
2143BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
2144BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
2145BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
2146BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
2147BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
2148BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
2149BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
2150BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
2151BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
2152BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
2153BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
2154
2155static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
2156{
2157 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
2158}
2159
2160BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
2161BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
2162BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
2163 stripe_len, 64);
2164BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
2165 io_align, 32);
2166BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
2167 io_width, 32);
2168BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
2169 sector_size, 32);
2170BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
2171BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
2172 num_stripes, 16);
2173BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
2174 sub_stripes, 16);
2175BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
2176BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
2177
2178static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
2179 int nr)
2180{
2181 unsigned long offset = (unsigned long)c;
2182 offset += offsetof(struct btrfs_chunk, stripe);
2183 offset += nr * sizeof(struct btrfs_stripe);
2184 return (struct btrfs_stripe *)offset;
2185}
2186
2187static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
2188{
2189 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
2190}
2191
2192static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
2193 struct btrfs_chunk *c, int nr)
2194{
2195 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
2196}
2197
2198static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
2199 struct btrfs_chunk *c, int nr)
2200{
2201 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
2202}
2203
2204
2205BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
2206 used, 64);
2207BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
2208 used, 64);
2209BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
2210 struct btrfs_block_group_item, chunk_objectid, 64);
2211
2212BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
2213 struct btrfs_block_group_item, chunk_objectid, 64);
2214BTRFS_SETGET_FUNCS(disk_block_group_flags,
2215 struct btrfs_block_group_item, flags, 64);
2216BTRFS_SETGET_STACK_FUNCS(block_group_flags,
2217 struct btrfs_block_group_item, flags, 64);
2218
2219
2220BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
2221BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
2222
2223
2224BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
2225 parent_objectid, 64);
2226BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
2227 name_len, 16);
2228BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
2229
2230
2231BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
2232BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
2233BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
2234BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
2235BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
2236BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
2237BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
2238BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
2239BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
2240BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
2241BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
2242BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
2243
2244static inline struct btrfs_timespec *
2245btrfs_inode_atime(struct btrfs_inode_item *inode_item)
2246{
2247 unsigned long ptr = (unsigned long)inode_item;
2248 ptr += offsetof(struct btrfs_inode_item, atime);
2249 return (struct btrfs_timespec *)ptr;
2250}
2251
2252static inline struct btrfs_timespec *
2253btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
2254{
2255 unsigned long ptr = (unsigned long)inode_item;
2256 ptr += offsetof(struct btrfs_inode_item, mtime);
2257 return (struct btrfs_timespec *)ptr;
2258}
2259
2260static inline struct btrfs_timespec *
2261btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
2262{
2263 unsigned long ptr = (unsigned long)inode_item;
2264 ptr += offsetof(struct btrfs_inode_item, ctime);
2265 return (struct btrfs_timespec *)ptr;
2266}
2267
2268BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
2269BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
2270
2271
2272BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
2273 chunk_tree, 64);
2274BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
2275 chunk_objectid, 64);
2276BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
2277 chunk_offset, 64);
2278BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
2279
2280static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
2281{
2282 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
2283 return (u8 *)((unsigned long)dev + ptr);
2284}
2285
2286BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
2287BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
2288 generation, 64);
2289BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
2290
2291BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
2292
2293
2294BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
2295
2296static inline void btrfs_tree_block_key(struct extent_buffer *eb,
2297 struct btrfs_tree_block_info *item,
2298 struct btrfs_disk_key *key)
2299{
2300 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2301}
2302
2303static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
2304 struct btrfs_tree_block_info *item,
2305 struct btrfs_disk_key *key)
2306{
2307 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2308}
2309
2310BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
2311 root, 64);
2312BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
2313 objectid, 64);
2314BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
2315 offset, 64);
2316BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
2317 count, 32);
2318
2319BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
2320 count, 32);
2321
2322BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
2323 type, 8);
2324BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
2325 offset, 64);
2326
2327static inline u32 btrfs_extent_inline_ref_size(int type)
2328{
2329 if (type == BTRFS_TREE_BLOCK_REF_KEY ||
2330 type == BTRFS_SHARED_BLOCK_REF_KEY)
2331 return sizeof(struct btrfs_extent_inline_ref);
2332 if (type == BTRFS_SHARED_DATA_REF_KEY)
2333 return sizeof(struct btrfs_shared_data_ref) +
2334 sizeof(struct btrfs_extent_inline_ref);
2335 if (type == BTRFS_EXTENT_DATA_REF_KEY)
2336 return sizeof(struct btrfs_extent_data_ref) +
2337 offsetof(struct btrfs_extent_inline_ref, offset);
2338 BUG();
2339 return 0;
2340}
2341
2342BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
2343BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
2344 generation, 64);
2345BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
2346BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
2347
2348
2349BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
2350BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
2351
2352static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
2353{
2354 unsigned long ptr;
2355 ptr = offsetof(struct btrfs_node, ptrs) +
2356 sizeof(struct btrfs_key_ptr) * nr;
2357 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
2358}
2359
2360static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
2361 int nr, u64 val)
2362{
2363 unsigned long ptr;
2364 ptr = offsetof(struct btrfs_node, ptrs) +
2365 sizeof(struct btrfs_key_ptr) * nr;
2366 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
2367}
2368
2369static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
2370{
2371 unsigned long ptr;
2372 ptr = offsetof(struct btrfs_node, ptrs) +
2373 sizeof(struct btrfs_key_ptr) * nr;
2374 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
2375}
2376
2377static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
2378 int nr, u64 val)
2379{
2380 unsigned long ptr;
2381 ptr = offsetof(struct btrfs_node, ptrs) +
2382 sizeof(struct btrfs_key_ptr) * nr;
2383 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
2384}
2385
2386static inline unsigned long btrfs_node_key_ptr_offset(int nr)
2387{
2388 return offsetof(struct btrfs_node, ptrs) +
2389 sizeof(struct btrfs_key_ptr) * nr;
2390}
2391
2392void btrfs_node_key(struct extent_buffer *eb,
2393 struct btrfs_disk_key *disk_key, int nr);
2394
2395static inline void btrfs_set_node_key(struct extent_buffer *eb,
2396 struct btrfs_disk_key *disk_key, int nr)
2397{
2398 unsigned long ptr;
2399 ptr = btrfs_node_key_ptr_offset(nr);
2400 write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
2401 struct btrfs_key_ptr, key, disk_key);
2402}
2403
2404
2405BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
2406BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
2407
2408static inline unsigned long btrfs_item_nr_offset(int nr)
2409{
2410 return offsetof(struct btrfs_leaf, items) +
2411 sizeof(struct btrfs_item) * nr;
2412}
2413
2414static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
2415 int nr)
2416{
2417 return (struct btrfs_item *)btrfs_item_nr_offset(nr);
2418}
2419
2420static inline u32 btrfs_item_end(struct extent_buffer *eb,
2421 struct btrfs_item *item)
2422{
2423 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
2424}
2425
2426static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
2427{
2428 return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
2429}
2430
2431static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
2432{
2433 return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
2434}
2435
2436static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
2437{
2438 return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
2439}
2440
2441static inline void btrfs_item_key(struct extent_buffer *eb,
2442 struct btrfs_disk_key *disk_key, int nr)
2443{
2444 struct btrfs_item *item = btrfs_item_nr(eb, nr);
2445 read_eb_member(eb, item, struct btrfs_item, key, disk_key);
2446}
2447
2448static inline void btrfs_set_item_key(struct extent_buffer *eb,
2449 struct btrfs_disk_key *disk_key, int nr)
2450{
2451 struct btrfs_item *item = btrfs_item_nr(eb, nr);
2452 write_eb_member(eb, item, struct btrfs_item, key, disk_key);
2453}
2454
2455BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
2456
2457
2458
2459
2460BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
2461BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
2462BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
2463
2464
2465BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
2466BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
2467BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
2468BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
2469
2470static inline void btrfs_dir_item_key(struct extent_buffer *eb,
2471 struct btrfs_dir_item *item,
2472 struct btrfs_disk_key *key)
2473{
2474 read_eb_member(eb, item, struct btrfs_dir_item, location, key);
2475}
2476
2477static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
2478 struct btrfs_dir_item *item,
2479 struct btrfs_disk_key *key)
2480{
2481 write_eb_member(eb, item, struct btrfs_dir_item, location, key);
2482}
2483
2484BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
2485 num_entries, 64);
2486BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
2487 num_bitmaps, 64);
2488BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
2489 generation, 64);
2490
2491static inline void btrfs_free_space_key(struct extent_buffer *eb,
2492 struct btrfs_free_space_header *h,
2493 struct btrfs_disk_key *key)
2494{
2495 read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2496}
2497
2498static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
2499 struct btrfs_free_space_header *h,
2500 struct btrfs_disk_key *key)
2501{
2502 write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2503}
2504
2505
2506BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
2507 objectid, 64);
2508BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2509BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2510
2511static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2512 struct btrfs_disk_key *disk)
2513{
2514 cpu->offset = le64_to_cpu(disk->offset);
2515 cpu->type = disk->type;
2516 cpu->objectid = le64_to_cpu(disk->objectid);
2517}
2518
2519static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
2520 struct btrfs_key *cpu)
2521{
2522 disk->offset = cpu_to_le64(cpu->offset);
2523 disk->type = cpu->type;
2524 disk->objectid = cpu_to_le64(cpu->objectid);
2525}
2526
2527static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
2528 struct btrfs_key *key, int nr)
2529{
2530 struct btrfs_disk_key disk_key;
2531 btrfs_node_key(eb, &disk_key, nr);
2532 btrfs_disk_key_to_cpu(key, &disk_key);
2533}
2534
2535static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
2536 struct btrfs_key *key, int nr)
2537{
2538 struct btrfs_disk_key disk_key;
2539 btrfs_item_key(eb, &disk_key, nr);
2540 btrfs_disk_key_to_cpu(key, &disk_key);
2541}
2542
2543static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
2544 struct btrfs_dir_item *item,
2545 struct btrfs_key *key)
2546{
2547 struct btrfs_disk_key disk_key;
2548 btrfs_dir_item_key(eb, item, &disk_key);
2549 btrfs_disk_key_to_cpu(key, &disk_key);
2550}
2551
2552
2553static inline u8 btrfs_key_type(struct btrfs_key *key)
2554{
2555 return key->type;
2556}
2557
2558static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2559{
2560 key->type = val;
2561}
2562
2563
2564BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2565BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2566 generation, 64);
2567BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2568BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
2569BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2570BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2571
2572static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
2573{
2574 return (btrfs_header_flags(eb) & flag) == flag;
2575}
2576
2577static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2578{
2579 u64 flags = btrfs_header_flags(eb);
2580 btrfs_set_header_flags(eb, flags | flag);
2581 return (flags & flag) == flag;
2582}
2583
2584static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2585{
2586 u64 flags = btrfs_header_flags(eb);
2587 btrfs_set_header_flags(eb, flags & ~flag);
2588 return (flags & flag) == flag;
2589}
2590
2591static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
2592{
2593 u64 flags = btrfs_header_flags(eb);
2594 return flags >> BTRFS_BACKREF_REV_SHIFT;
2595}
2596
2597static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2598 int rev)
2599{
2600 u64 flags = btrfs_header_flags(eb);
2601 flags &= ~BTRFS_BACKREF_REV_MASK;
2602 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2603 btrfs_set_header_flags(eb, flags);
2604}
2605
2606static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
2607{
2608 unsigned long ptr = offsetof(struct btrfs_header, fsid);
2609 return (u8 *)ptr;
2610}
2611
2612static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
2613{
2614 unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);
2615 return (u8 *)ptr;
2616}
2617
2618static inline int btrfs_is_leaf(struct extent_buffer *eb)
2619{
2620 return btrfs_header_level(eb) == 0;
2621}
2622
2623
2624BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2625 generation, 64);
2626BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2627BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2628BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2629
2630BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2631 generation, 64);
2632BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2633BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2634BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2635BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2636BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2637BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2638BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
2639BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2640 last_snapshot, 64);
2641BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2642 generation_v2, 64);
2643BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2644 ctransid, 64);
2645BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2646 otransid, 64);
2647BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2648 stransid, 64);
2649BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2650 rtransid, 64);
2651
2652static inline bool btrfs_root_readonly(struct btrfs_root *root)
2653{
2654 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
2655}
2656
2657
2658BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2659 tree_root, 64);
2660BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2661 tree_root_gen, 64);
2662BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2663 tree_root_level, 8);
2664
2665BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2666 chunk_root, 64);
2667BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2668 chunk_root_gen, 64);
2669BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2670 chunk_root_level, 8);
2671
2672BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2673 extent_root, 64);
2674BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2675 extent_root_gen, 64);
2676BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2677 extent_root_level, 8);
2678
2679BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2680 fs_root, 64);
2681BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2682 fs_root_gen, 64);
2683BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2684 fs_root_level, 8);
2685
2686BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2687 dev_root, 64);
2688BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2689 dev_root_gen, 64);
2690BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2691 dev_root_level, 8);
2692
2693BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2694 csum_root, 64);
2695BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2696 csum_root_gen, 64);
2697BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2698 csum_root_level, 8);
2699BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2700 total_bytes, 64);
2701BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2702 bytes_used, 64);
2703BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2704 num_devices, 64);
2705
2706
2707BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2708
2709static inline void btrfs_balance_data(struct extent_buffer *eb,
2710 struct btrfs_balance_item *bi,
2711 struct btrfs_disk_balance_args *ba)
2712{
2713 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2714}
2715
2716static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2717 struct btrfs_balance_item *bi,
2718 struct btrfs_disk_balance_args *ba)
2719{
2720 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2721}
2722
2723static inline void btrfs_balance_meta(struct extent_buffer *eb,
2724 struct btrfs_balance_item *bi,
2725 struct btrfs_disk_balance_args *ba)
2726{
2727 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2728}
2729
2730static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2731 struct btrfs_balance_item *bi,
2732 struct btrfs_disk_balance_args *ba)
2733{
2734 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2735}
2736
2737static inline void btrfs_balance_sys(struct extent_buffer *eb,
2738 struct btrfs_balance_item *bi,
2739 struct btrfs_disk_balance_args *ba)
2740{
2741 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2742}
2743
2744static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2745 struct btrfs_balance_item *bi,
2746 struct btrfs_disk_balance_args *ba)
2747{
2748 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2749}
2750
2751static inline void
2752btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2753 struct btrfs_disk_balance_args *disk)
2754{
2755 memset(cpu, 0, sizeof(*cpu));
2756
2757 cpu->profiles = le64_to_cpu(disk->profiles);
2758 cpu->usage = le64_to_cpu(disk->usage);
2759 cpu->devid = le64_to_cpu(disk->devid);
2760 cpu->pstart = le64_to_cpu(disk->pstart);
2761 cpu->pend = le64_to_cpu(disk->pend);
2762 cpu->vstart = le64_to_cpu(disk->vstart);
2763 cpu->vend = le64_to_cpu(disk->vend);
2764 cpu->target = le64_to_cpu(disk->target);
2765 cpu->flags = le64_to_cpu(disk->flags);
2766}
2767
2768static inline void
2769btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2770 struct btrfs_balance_args *cpu)
2771{
2772 memset(disk, 0, sizeof(*disk));
2773
2774 disk->profiles = cpu_to_le64(cpu->profiles);
2775 disk->usage = cpu_to_le64(cpu->usage);
2776 disk->devid = cpu_to_le64(cpu->devid);
2777 disk->pstart = cpu_to_le64(cpu->pstart);
2778 disk->pend = cpu_to_le64(cpu->pend);
2779 disk->vstart = cpu_to_le64(cpu->vstart);
2780 disk->vend = cpu_to_le64(cpu->vend);
2781 disk->target = cpu_to_le64(cpu->target);
2782 disk->flags = cpu_to_le64(cpu->flags);
2783}
2784
2785
2786BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2787BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2788BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2789 generation, 64);
2790BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2791BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2792 struct btrfs_super_block, sys_chunk_array_size, 32);
2793BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2794 struct btrfs_super_block, chunk_root_generation, 64);
2795BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2796 root_level, 8);
2797BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2798 chunk_root, 64);
2799BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2800 chunk_root_level, 8);
2801BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2802 log_root, 64);
2803BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2804 log_root_transid, 64);
2805BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2806 log_root_level, 8);
2807BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2808 total_bytes, 64);
2809BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2810 bytes_used, 64);
2811BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2812 sectorsize, 32);
2813BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2814 nodesize, 32);
2815BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
2816 leafsize, 32);
2817BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2818 stripesize, 32);
2819BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2820 root_dir_objectid, 64);
2821BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2822 num_devices, 64);
2823BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2824 compat_flags, 64);
2825BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2826 compat_ro_flags, 64);
2827BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2828 incompat_flags, 64);
2829BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2830 csum_type, 16);
2831BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2832 cache_generation, 64);
2833
2834static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
2835{
2836 u16 t = btrfs_super_csum_type(s);
2837
2838
2839
2840 return btrfs_csum_sizes[t];
2841}
2842
2843static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
2844{
2845 return offsetof(struct btrfs_leaf, items);
2846}
2847
2848
2849BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2850
2851static inline unsigned long
2852btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
2853{
2854 unsigned long offset = (unsigned long)e;
2855 offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
2856 return offset;
2857}
2858
2859static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2860{
2861 return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
2862}
2863
2864BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2865 disk_bytenr, 64);
2866BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2867 generation, 64);
2868BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2869 disk_num_bytes, 64);
2870BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2871 offset, 64);
2872BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2873 num_bytes, 64);
2874BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2875 ram_bytes, 64);
2876BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2877 compression, 8);
2878BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2879 encryption, 8);
2880BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2881 other_encoding, 16);
2882
2883
2884
2885
2886static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
2887 struct btrfs_file_extent_item *e)
2888{
2889 return btrfs_file_extent_ram_bytes(eb, e);
2890}
2891
2892
2893
2894
2895
2896
2897static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
2898 struct btrfs_item *e)
2899{
2900 unsigned long offset;
2901 offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
2902 return btrfs_item_size(eb, e) - offset;
2903}
2904
2905
2906static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb,
2907 struct btrfs_dev_stats_item *ptr,
2908 int index)
2909{
2910 u64 val;
2911
2912 read_extent_buffer(eb, &val,
2913 offsetof(struct btrfs_dev_stats_item, values) +
2914 ((unsigned long)ptr) + (index * sizeof(u64)),
2915 sizeof(val));
2916 return val;
2917}
2918
2919static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
2920 struct btrfs_dev_stats_item *ptr,
2921 int index, u64 val)
2922{
2923 write_extent_buffer(eb, &val,
2924 offsetof(struct btrfs_dev_stats_item, values) +
2925 ((unsigned long)ptr) + (index * sizeof(u64)),
2926 sizeof(val));
2927}
2928
2929
2930BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2931 generation, 64);
2932BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2933 version, 64);
2934BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2935 flags, 64);
2936BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
2937 rescan, 64);
2938
2939
2940BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2941 generation, 64);
2942BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2943BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2944 rfer_cmpr, 64);
2945BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2946BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2947 excl_cmpr, 64);
2948
2949BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2950 struct btrfs_qgroup_info_item, generation, 64);
2951BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2952 rfer, 64);
2953BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2954 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2955BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2956 excl, 64);
2957BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2958 struct btrfs_qgroup_info_item, excl_cmpr, 64);
2959
2960
2961BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2962 flags, 64);
2963BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2964 max_rfer, 64);
2965BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2966 max_excl, 64);
2967BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2968 rsv_rfer, 64);
2969BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2970 rsv_excl, 64);
2971
2972
2973BTRFS_SETGET_FUNCS(dev_replace_src_devid,
2974 struct btrfs_dev_replace_item, src_devid, 64);
2975BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
2976 struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
2977 64);
2978BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
2979 replace_state, 64);
2980BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
2981 time_started, 64);
2982BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
2983 time_stopped, 64);
2984BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
2985 num_write_errors, 64);
2986BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
2987 struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
2988 64);
2989BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
2990 cursor_left, 64);
2991BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
2992 cursor_right, 64);
2993
2994BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
2995 struct btrfs_dev_replace_item, src_devid, 64);
2996BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
2997 struct btrfs_dev_replace_item,
2998 cont_reading_from_srcdev_mode, 64);
2999BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
3000 struct btrfs_dev_replace_item, replace_state, 64);
3001BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
3002 struct btrfs_dev_replace_item, time_started, 64);
3003BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
3004 struct btrfs_dev_replace_item, time_stopped, 64);
3005BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
3006 struct btrfs_dev_replace_item, num_write_errors, 64);
3007BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
3008 struct btrfs_dev_replace_item,
3009 num_uncorrectable_read_errors, 64);
3010BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
3011 struct btrfs_dev_replace_item, cursor_left, 64);
3012BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
3013 struct btrfs_dev_replace_item, cursor_right, 64);
3014
3015static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
3016{
3017 return sb->s_fs_info;
3018}
3019
3020static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
3021{
3022 if (level == 0)
3023 return root->leafsize;
3024 return root->nodesize;
3025}
3026
3027
3028#define btrfs_item_ptr(leaf, slot, type) \
3029 ((type *)(btrfs_leaf_data(leaf) + \
3030 btrfs_item_offset_nr(leaf, slot)))
3031
3032#define btrfs_item_ptr_offset(leaf, slot) \
3033 ((unsigned long)(btrfs_leaf_data(leaf) + \
3034 btrfs_item_offset_nr(leaf, slot)))
3035
3036static inline struct dentry *fdentry(struct file *file)
3037{
3038 return file->f_path.dentry;
3039}
3040
3041static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
3042{
3043 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
3044 (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
3045}
3046
3047static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
3048{
3049 return mapping_gfp_mask(mapping) & ~__GFP_FS;
3050}
3051
3052
3053static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
3054 unsigned num_items)
3055{
3056 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
3057 3 * num_items;
3058}
3059
3060
3061
3062
3063
3064static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
3065 unsigned num_items)
3066{
3067 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
3068 num_items;
3069}
3070
3071int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
3072 struct btrfs_root *root);
3073void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
3074int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
3075 struct btrfs_root *root, unsigned long count);
3076int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
3077int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
3078 struct btrfs_root *root, u64 bytenr,
3079 u64 offset, int metadata, u64 *refs, u64 *flags);
3080int btrfs_pin_extent(struct btrfs_root *root,
3081 u64 bytenr, u64 num, int reserved);
3082int btrfs_pin_extent_for_log_replay(struct btrfs_root *root,
3083 u64 bytenr, u64 num_bytes);
3084int btrfs_exclude_logged_extents(struct btrfs_root *root,
3085 struct extent_buffer *eb);
3086int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
3087 struct btrfs_root *root,
3088 u64 objectid, u64 offset, u64 bytenr);
3089struct btrfs_block_group_cache *btrfs_lookup_block_group(
3090 struct btrfs_fs_info *info,
3091 u64 bytenr);
3092void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
3093struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
3094 struct btrfs_root *root, u32 blocksize,
3095 u64 parent, u64 root_objectid,
3096 struct btrfs_disk_key *key, int level,
3097 u64 hint, u64 empty_size);
3098void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
3099 struct btrfs_root *root,
3100 struct extent_buffer *buf,
3101 u64 parent, int last_ref);
3102int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
3103 struct btrfs_root *root,
3104 u64 root_objectid, u64 owner,
3105 u64 offset, struct btrfs_key *ins);
3106int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
3107 struct btrfs_root *root,
3108 u64 root_objectid, u64 owner, u64 offset,
3109 struct btrfs_key *ins);
3110int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
3111 struct btrfs_root *root,
3112 u64 num_bytes, u64 min_alloc_size,
3113 u64 empty_size, u64 hint_byte,
3114 struct btrfs_key *ins, int is_data);
3115int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3116 struct extent_buffer *buf, int full_backref, int for_cow);
3117int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3118 struct extent_buffer *buf, int full_backref, int for_cow);
3119int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
3120 struct btrfs_root *root,
3121 u64 bytenr, u64 num_bytes, u64 flags,
3122 int level, int is_data);
3123int btrfs_free_extent(struct btrfs_trans_handle *trans,
3124 struct btrfs_root *root,
3125 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
3126 u64 owner, u64 offset, int for_cow);
3127
3128int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
3129int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
3130 u64 start, u64 len);
3131void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
3132 struct btrfs_root *root);
3133int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
3134 struct btrfs_root *root);
3135int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
3136 struct btrfs_root *root,
3137 u64 bytenr, u64 num_bytes, u64 parent,
3138 u64 root_objectid, u64 owner, u64 offset, int for_cow);
3139
3140int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
3141 struct btrfs_root *root);
3142int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
3143int btrfs_free_block_groups(struct btrfs_fs_info *info);
3144int btrfs_read_block_groups(struct btrfs_root *root);
3145int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
3146int btrfs_make_block_group(struct btrfs_trans_handle *trans,
3147 struct btrfs_root *root, u64 bytes_used,
3148 u64 type, u64 chunk_objectid, u64 chunk_offset,
3149 u64 size);
3150int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
3151 struct btrfs_root *root, u64 group_start);
3152void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
3153 struct btrfs_root *root);
3154u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
3155void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
3156
3157enum btrfs_reserve_flush_enum {
3158
3159 BTRFS_RESERVE_NO_FLUSH,
3160
3161
3162
3163
3164 BTRFS_RESERVE_FLUSH_LIMIT,
3165 BTRFS_RESERVE_FLUSH_ALL,
3166};
3167
3168int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
3169void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
3170void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
3171 struct btrfs_root *root);
3172int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
3173 struct inode *inode);
3174void btrfs_orphan_release_metadata(struct inode *inode);
3175int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
3176 struct btrfs_block_rsv *rsv,
3177 int nitems,
3178 u64 *qgroup_reserved);
3179void btrfs_subvolume_release_metadata(struct btrfs_root *root,
3180 struct btrfs_block_rsv *rsv,
3181 u64 qgroup_reserved);
3182int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
3183void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
3184int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
3185void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
3186void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
3187struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
3188 unsigned short type);
3189void btrfs_free_block_rsv(struct btrfs_root *root,
3190 struct btrfs_block_rsv *rsv);
3191int btrfs_block_rsv_add(struct btrfs_root *root,
3192 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
3193 enum btrfs_reserve_flush_enum flush);
3194int btrfs_block_rsv_check(struct btrfs_root *root,
3195 struct btrfs_block_rsv *block_rsv, int min_factor);
3196int btrfs_block_rsv_refill(struct btrfs_root *root,
3197 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
3198 enum btrfs_reserve_flush_enum flush);
3199int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
3200 struct btrfs_block_rsv *dst_rsv,
3201 u64 num_bytes);
3202int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
3203 struct btrfs_block_rsv *dest, u64 num_bytes,
3204 int min_factor);
3205void btrfs_block_rsv_release(struct btrfs_root *root,
3206 struct btrfs_block_rsv *block_rsv,
3207 u64 num_bytes);
3208int btrfs_set_block_group_ro(struct btrfs_root *root,
3209 struct btrfs_block_group_cache *cache);
3210void btrfs_set_block_group_rw(struct btrfs_root *root,
3211 struct btrfs_block_group_cache *cache);
3212void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
3213u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
3214int btrfs_error_unpin_extent_range(struct btrfs_root *root,
3215 u64 start, u64 end);
3216int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
3217 u64 num_bytes, u64 *actual_bytes);
3218int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
3219 struct btrfs_root *root, u64 type);
3220int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
3221
3222int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
3223int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
3224 struct btrfs_fs_info *fs_info);
3225int __get_raid_index(u64 flags);
3226
3227int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
3228 int level, int *slot);
3229int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
3230int btrfs_previous_item(struct btrfs_root *root,
3231 struct btrfs_path *path, u64 min_objectid,
3232 int type);
3233void btrfs_set_item_key_safe(struct btrfs_root *root, struct btrfs_path *path,
3234 struct btrfs_key *new_key);
3235struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
3236struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
3237int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
3238 struct btrfs_key *key, int lowest_level,
3239 u64 min_trans);
3240int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
3241 struct btrfs_key *max_key,
3242 struct btrfs_path *path,
3243 u64 min_trans);
3244enum btrfs_compare_tree_result {
3245 BTRFS_COMPARE_TREE_NEW,
3246 BTRFS_COMPARE_TREE_DELETED,
3247 BTRFS_COMPARE_TREE_CHANGED,
3248};
3249typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root,
3250 struct btrfs_root *right_root,
3251 struct btrfs_path *left_path,
3252 struct btrfs_path *right_path,
3253 struct btrfs_key *key,
3254 enum btrfs_compare_tree_result result,
3255 void *ctx);
3256int btrfs_compare_trees(struct btrfs_root *left_root,
3257 struct btrfs_root *right_root,
3258 btrfs_changed_cb_t cb, void *ctx);
3259int btrfs_cow_block(struct btrfs_trans_handle *trans,
3260 struct btrfs_root *root, struct extent_buffer *buf,
3261 struct extent_buffer *parent, int parent_slot,
3262 struct extent_buffer **cow_ret);
3263int btrfs_copy_root(struct btrfs_trans_handle *trans,
3264 struct btrfs_root *root,
3265 struct extent_buffer *buf,
3266 struct extent_buffer **cow_ret, u64 new_root_objectid);
3267int btrfs_block_can_be_shared(struct btrfs_root *root,
3268 struct extent_buffer *buf);
3269void btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
3270 u32 data_size);
3271void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
3272 u32 new_size, int from_end);
3273int btrfs_split_item(struct btrfs_trans_handle *trans,
3274 struct btrfs_root *root,
3275 struct btrfs_path *path,
3276 struct btrfs_key *new_key,
3277 unsigned long split_offset);
3278int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
3279 struct btrfs_root *root,
3280 struct btrfs_path *path,
3281 struct btrfs_key *new_key);
3282int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
3283 *root, struct btrfs_key *key, struct btrfs_path *p, int
3284 ins_len, int cow);
3285int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
3286 struct btrfs_path *p, u64 time_seq);
3287int btrfs_search_slot_for_read(struct btrfs_root *root,
3288 struct btrfs_key *key, struct btrfs_path *p,
3289 int find_higher, int return_any);
3290int btrfs_realloc_node(struct btrfs_trans_handle *trans,
3291 struct btrfs_root *root, struct extent_buffer *parent,
3292 int start_slot, u64 *last_ret,
3293 struct btrfs_key *progress);
3294void btrfs_release_path(struct btrfs_path *p);
3295struct btrfs_path *btrfs_alloc_path(void);
3296void btrfs_free_path(struct btrfs_path *p);
3297void btrfs_set_path_blocking(struct btrfs_path *p);
3298void btrfs_clear_path_blocking(struct btrfs_path *p,
3299 struct extent_buffer *held, int held_rw);
3300void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
3301
3302int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3303 struct btrfs_path *path, int slot, int nr);
3304static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
3305 struct btrfs_root *root,
3306 struct btrfs_path *path)
3307{
3308 return btrfs_del_items(trans, root, path, path->slots[0], 1);
3309}
3310
3311void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
3312 struct btrfs_key *cpu_key, u32 *data_size,
3313 u32 total_data, u32 total_size, int nr);
3314int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
3315 *root, struct btrfs_key *key, void *data, u32 data_size);
3316int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
3317 struct btrfs_root *root,
3318 struct btrfs_path *path,
3319 struct btrfs_key *cpu_key, u32 *data_size, int nr);
3320
3321static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
3322 struct btrfs_root *root,
3323 struct btrfs_path *path,
3324 struct btrfs_key *key,
3325 u32 data_size)
3326{
3327 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
3328}
3329
3330int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
3331int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
3332 u64 time_seq);
3333static inline int btrfs_next_old_item(struct btrfs_root *root,
3334 struct btrfs_path *p, u64 time_seq)
3335{
3336 ++p->slots[0];
3337 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
3338 return btrfs_next_old_leaf(root, p, time_seq);
3339 return 0;
3340}
3341static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
3342{
3343 return btrfs_next_old_item(root, p, 0);
3344}
3345int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
3346int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
3347 struct btrfs_block_rsv *block_rsv,
3348 int update_ref, int for_reloc);
3349int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
3350 struct btrfs_root *root,
3351 struct extent_buffer *node,
3352 struct extent_buffer *parent);
3353static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
3354{
3355
3356
3357
3358 smp_mb();
3359 return fs_info->closing;
3360}
3361
3362
3363
3364
3365
3366
3367static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root)
3368{
3369 return (root->fs_info->sb->s_flags & MS_RDONLY ||
3370 btrfs_fs_closing(root->fs_info));
3371}
3372
3373static inline void free_fs_info(struct btrfs_fs_info *fs_info)
3374{
3375 kfree(fs_info->balance_ctl);
3376 kfree(fs_info->delayed_root);
3377 kfree(fs_info->extent_root);
3378 kfree(fs_info->tree_root);
3379 kfree(fs_info->chunk_root);
3380 kfree(fs_info->dev_root);
3381 kfree(fs_info->csum_root);
3382 kfree(fs_info->quota_root);
3383 kfree(fs_info->super_copy);
3384 kfree(fs_info->super_for_commit);
3385 kfree(fs_info);
3386}
3387
3388
3389u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
3390 struct seq_list *elem);
3391void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
3392 struct seq_list *elem);
3393u64 btrfs_tree_mod_seq_prev(u64 seq);
3394int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
3395
3396
3397int btrfs_find_root_ref(struct btrfs_root *tree_root,
3398 struct btrfs_path *path,
3399 u64 root_id, u64 ref_id);
3400int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
3401 struct btrfs_root *tree_root,
3402 u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
3403 const char *name, int name_len);
3404int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
3405 struct btrfs_root *tree_root,
3406 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
3407 const char *name, int name_len);
3408int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3409 struct btrfs_key *key);
3410int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
3411 *root, struct btrfs_key *key, struct btrfs_root_item
3412 *item);
3413int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
3414 struct btrfs_root *root,
3415 struct btrfs_key *key,
3416 struct btrfs_root_item *item);
3417void btrfs_read_root_item(struct extent_buffer *eb, int slot,
3418 struct btrfs_root_item *item);
3419int btrfs_find_root(struct btrfs_root *root, struct btrfs_key *search_key,
3420 struct btrfs_path *path, struct btrfs_root_item *root_item,
3421 struct btrfs_key *root_key);
3422int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
3423void btrfs_set_root_node(struct btrfs_root_item *item,
3424 struct extent_buffer *node);
3425void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
3426void btrfs_update_root_times(struct btrfs_trans_handle *trans,
3427 struct btrfs_root *root);
3428
3429
3430int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3431 const char *name, int name_len);
3432int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
3433 struct btrfs_root *root, const char *name,
3434 int name_len, struct inode *dir,
3435 struct btrfs_key *location, u8 type, u64 index);
3436struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
3437 struct btrfs_root *root,
3438 struct btrfs_path *path, u64 dir,
3439 const char *name, int name_len,
3440 int mod);
3441struct btrfs_dir_item *
3442btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
3443 struct btrfs_root *root,
3444 struct btrfs_path *path, u64 dir,
3445 u64 objectid, const char *name, int name_len,
3446 int mod);
3447struct btrfs_dir_item *
3448btrfs_search_dir_index_item(struct btrfs_root *root,
3449 struct btrfs_path *path, u64 dirid,
3450 const char *name, int name_len);
3451int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
3452 struct btrfs_root *root,
3453 struct btrfs_path *path,
3454 struct btrfs_dir_item *di);
3455int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3456 struct btrfs_root *root,
3457 struct btrfs_path *path, u64 objectid,
3458 const char *name, u16 name_len,
3459 const void *data, u16 data_len);
3460struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3461 struct btrfs_root *root,
3462 struct btrfs_path *path, u64 dir,
3463 const char *name, u16 name_len,
3464 int mod);
3465int verify_dir_item(struct btrfs_root *root,
3466 struct extent_buffer *leaf,
3467 struct btrfs_dir_item *dir_item);
3468
3469
3470int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3471 struct btrfs_root *root, u64 offset);
3472int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3473 struct btrfs_root *root, u64 offset);
3474int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3475
3476
3477int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
3478 struct btrfs_root *root,
3479 const char *name, int name_len,
3480 u64 inode_objectid, u64 ref_objectid, u64 index);
3481int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
3482 struct btrfs_root *root,
3483 const char *name, int name_len,
3484 u64 inode_objectid, u64 ref_objectid, u64 *index);
3485int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
3486 struct btrfs_root *root,
3487 struct btrfs_path *path,
3488 const char *name, int name_len,
3489 u64 inode_objectid, u64 ref_objectid, int mod,
3490 u64 *ret_index);
3491int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
3492 struct btrfs_root *root,
3493 struct btrfs_path *path, u64 objectid);
3494int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
3495 *root, struct btrfs_path *path,
3496 struct btrfs_key *location, int mod);
3497
3498struct btrfs_inode_extref *
3499btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
3500 struct btrfs_root *root,
3501 struct btrfs_path *path,
3502 const char *name, int name_len,
3503 u64 inode_objectid, u64 ref_objectid, int ins_len,
3504 int cow);
3505
3506int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
3507 u64 ref_objectid, const char *name,
3508 int name_len,
3509 struct btrfs_inode_extref **extref_ret);
3510
3511
3512int btrfs_del_csums(struct btrfs_trans_handle *trans,
3513 struct btrfs_root *root, u64 bytenr, u64 len);
3514int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
3515 struct bio *bio, u32 *dst);
3516int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
3517 struct bio *bio, u64 logical_offset);
3518int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3519 struct btrfs_root *root,
3520 u64 objectid, u64 pos,
3521 u64 disk_offset, u64 disk_num_bytes,
3522 u64 num_bytes, u64 offset, u64 ram_bytes,
3523 u8 compression, u8 encryption, u16 other_encoding);
3524int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3525 struct btrfs_root *root,
3526 struct btrfs_path *path, u64 objectid,
3527 u64 bytenr, int mod);
3528int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3529 struct btrfs_root *root,
3530 struct btrfs_ordered_sum *sums);
3531int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
3532 struct bio *bio, u64 file_start, int contig);
3533int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
3534 struct btrfs_root *root, struct btrfs_path *path,
3535 u64 isize);
3536int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3537 struct list_head *list, int search_commit);
3538
3539struct btrfs_delalloc_work {
3540 struct inode *inode;
3541 int wait;
3542 int delay_iput;
3543 struct completion completion;
3544 struct list_head list;
3545 struct btrfs_work work;
3546};
3547
3548struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
3549 int wait, int delay_iput);
3550void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
3551
3552struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
3553 size_t pg_offset, u64 start, u64 len,
3554 int create);
3555noinline int can_nocow_extent(struct btrfs_trans_handle *trans,
3556 struct inode *inode, u64 offset, u64 *len,
3557 u64 *orig_start, u64 *orig_block_len,
3558 u64 *ram_bytes);
3559
3560
3561#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
3562#define ClearPageChecked ClearPageFsMisc
3563#define SetPageChecked SetPageFsMisc
3564#define PageChecked PageFsMisc
3565#endif
3566
3567
3568static inline void btrfs_force_ra(struct address_space *mapping,
3569 struct file_ra_state *ra, struct file *file,
3570 pgoff_t offset, unsigned long req_size)
3571{
3572 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
3573}
3574
3575struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3576int btrfs_set_inode_index(struct inode *dir, u64 *index);
3577int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3578 struct btrfs_root *root,
3579 struct inode *dir, struct inode *inode,
3580 const char *name, int name_len);
3581int btrfs_add_link(struct btrfs_trans_handle *trans,
3582 struct inode *parent_inode, struct inode *inode,
3583 const char *name, int name_len, int add_backref, u64 index);
3584int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3585 struct btrfs_root *root,
3586 struct inode *dir, u64 objectid,
3587 const char *name, int name_len);
3588int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
3589 int front);
3590int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3591 struct btrfs_root *root,
3592 struct inode *inode, u64 new_size,
3593 u32 min_type);
3594
3595int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
3596int btrfs_start_all_delalloc_inodes(struct btrfs_fs_info *fs_info,
3597 int delay_iput);
3598int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3599 struct extent_state **cached_state);
3600int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3601 struct btrfs_root *new_root, u64 new_dirid);
3602int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
3603 size_t size, struct bio *bio,
3604 unsigned long bio_flags);
3605int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
3606int btrfs_readpage(struct file *file, struct page *page);
3607void btrfs_evict_inode(struct inode *inode);
3608int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
3609struct inode *btrfs_alloc_inode(struct super_block *sb);
3610void btrfs_destroy_inode(struct inode *inode);
3611int btrfs_drop_inode(struct inode *inode);
3612int btrfs_init_cachep(void);
3613void btrfs_destroy_cachep(void);
3614long btrfs_ioctl_trans_end(struct file *file);
3615struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3616 struct btrfs_root *root, int *was_new);
3617struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3618 size_t pg_offset, u64 start, u64 end,
3619 int create);
3620int btrfs_update_inode(struct btrfs_trans_handle *trans,
3621 struct btrfs_root *root,
3622 struct inode *inode);
3623int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3624 struct btrfs_root *root, struct inode *inode);
3625int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
3626int btrfs_orphan_cleanup(struct btrfs_root *root);
3627void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3628 struct btrfs_root *root);
3629int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3630void btrfs_invalidate_inodes(struct btrfs_root *root);
3631void btrfs_add_delayed_iput(struct inode *inode);
3632void btrfs_run_delayed_iputs(struct btrfs_root *root);
3633int btrfs_prealloc_file_range(struct inode *inode, int mode,
3634 u64 start, u64 num_bytes, u64 min_size,
3635 loff_t actual_len, u64 *alloc_hint);
3636int btrfs_prealloc_file_range_trans(struct inode *inode,
3637 struct btrfs_trans_handle *trans, int mode,
3638 u64 start, u64 num_bytes, u64 min_size,
3639 loff_t actual_len, u64 *alloc_hint);
3640extern const struct dentry_operations btrfs_dentry_operations;
3641
3642
3643long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3644void btrfs_update_iflags(struct inode *inode);
3645void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
3646int btrfs_defrag_file(struct inode *inode, struct file *file,
3647 struct btrfs_ioctl_defrag_range_args *range,
3648 u64 newer_than, unsigned long max_pages);
3649void btrfs_get_block_group_info(struct list_head *groups_list,
3650 struct btrfs_ioctl_space_info *space);
3651
3652
3653int btrfs_auto_defrag_init(void);
3654void btrfs_auto_defrag_exit(void);
3655int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3656 struct inode *inode);
3657int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3658void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
3659int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3660void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
3661 int skip_pinned);
3662int btrfs_replace_extent_cache(struct inode *inode, struct extent_map *replace,
3663 u64 start, u64 end, int skip_pinned,
3664 int modified);
3665extern const struct file_operations btrfs_file_operations;
3666int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3667 struct btrfs_root *root, struct inode *inode,
3668 struct btrfs_path *path, u64 start, u64 end,
3669 u64 *drop_end, int drop_cache);
3670int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3671 struct btrfs_root *root, struct inode *inode, u64 start,
3672 u64 end, int drop_cache);
3673int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3674 struct inode *inode, u64 start, u64 end);
3675int btrfs_release_file(struct inode *inode, struct file *file);
3676int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
3677 struct page **pages, size_t num_pages,
3678 loff_t pos, size_t write_bytes,
3679 struct extent_state **cached);
3680
3681
3682int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3683 struct btrfs_root *root);
3684
3685
3686int btrfs_init_sysfs(void);
3687void btrfs_exit_sysfs(void);
3688
3689
3690ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
3691
3692
3693int btrfs_parse_options(struct btrfs_root *root, char *options);
3694int btrfs_sync_fs(struct super_block *sb, int wait);
3695
3696#ifdef CONFIG_PRINTK
3697__printf(2, 3)
3698void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3699#else
3700static inline __printf(2, 3)
3701void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
3702{
3703}
3704#endif
3705
3706#define btrfs_emerg(fs_info, fmt, args...) \
3707 btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
3708#define btrfs_alert(fs_info, fmt, args...) \
3709 btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
3710#define btrfs_crit(fs_info, fmt, args...) \
3711 btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
3712#define btrfs_err(fs_info, fmt, args...) \
3713 btrfs_printk(fs_info, KERN_ERR fmt, ##args)
3714#define btrfs_warn(fs_info, fmt, args...) \
3715 btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
3716#define btrfs_notice(fs_info, fmt, args...) \
3717 btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
3718#define btrfs_info(fs_info, fmt, args...) \
3719 btrfs_printk(fs_info, KERN_INFO fmt, ##args)
3720#define btrfs_debug(fs_info, fmt, args...) \
3721 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3722
3723__printf(5, 6)
3724void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
3725 unsigned int line, int errno, const char *fmt, ...);
3726
3727
3728void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3729 struct btrfs_root *root, const char *function,
3730 unsigned int line, int errno);
3731
3732#define btrfs_set_fs_incompat(__fs_info, opt) \
3733 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3734
3735static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3736 u64 flag)
3737{
3738 struct btrfs_super_block *disk_super;
3739 u64 features;
3740
3741 disk_super = fs_info->super_copy;
3742 features = btrfs_super_incompat_flags(disk_super);
3743 if (!(features & flag)) {
3744 spin_lock(&fs_info->super_lock);
3745 features = btrfs_super_incompat_flags(disk_super);
3746 if (!(features & flag)) {
3747 features |= flag;
3748 btrfs_set_super_incompat_flags(disk_super, features);
3749 printk(KERN_INFO "btrfs: setting %llu feature flag\n",
3750 flag);
3751 }
3752 spin_unlock(&fs_info->super_lock);
3753 }
3754}
3755
3756#define btrfs_fs_incompat(fs_info, opt) \
3757 __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3758
3759static inline int __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3760{
3761 struct btrfs_super_block *disk_super;
3762 disk_super = fs_info->super_copy;
3763 return !!(btrfs_super_incompat_flags(disk_super) & flag);
3764}
3765
3766
3767
3768
3769
3770
3771#define btrfs_abort_transaction(trans, root, errno) \
3772do { \
3773 __btrfs_abort_transaction(trans, root, __func__, \
3774 __LINE__, errno); \
3775} while (0)
3776
3777#define btrfs_std_error(fs_info, errno) \
3778do { \
3779 if ((errno)) \
3780 __btrfs_std_error((fs_info), __func__, \
3781 __LINE__, (errno), NULL); \
3782} while (0)
3783
3784#define btrfs_error(fs_info, errno, fmt, args...) \
3785do { \
3786 __btrfs_std_error((fs_info), __func__, __LINE__, \
3787 (errno), fmt, ##args); \
3788} while (0)
3789
3790__printf(5, 6)
3791void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3792 unsigned int line, int errno, const char *fmt, ...);
3793
3794
3795
3796
3797
3798#define btrfs_panic(fs_info, errno, fmt, args...) \
3799do { \
3800 __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \
3801 BUG(); \
3802} while (0)
3803
3804
3805#ifdef CONFIG_BTRFS_FS_POSIX_ACL
3806struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3807int btrfs_init_acl(struct btrfs_trans_handle *trans,
3808 struct inode *inode, struct inode *dir);
3809int btrfs_acl_chmod(struct inode *inode);
3810#else
3811#define btrfs_get_acl NULL
3812static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
3813 struct inode *inode, struct inode *dir)
3814{
3815 return 0;
3816}
3817static inline int btrfs_acl_chmod(struct inode *inode)
3818{
3819 return 0;
3820}
3821#endif
3822
3823
3824int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
3825int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3826 struct btrfs_root *root);
3827int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3828 struct btrfs_root *root);
3829int btrfs_recover_relocation(struct btrfs_root *root);
3830int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
3831void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3832 struct btrfs_root *root, struct extent_buffer *buf,
3833 struct extent_buffer *cow);
3834void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
3835 struct btrfs_pending_snapshot *pending,
3836 u64 *bytes_to_reserve);
3837int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3838 struct btrfs_pending_snapshot *pending);
3839
3840
3841int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
3842 u64 end, struct btrfs_scrub_progress *progress,
3843 int readonly, int is_dev_replace);
3844void btrfs_scrub_pause(struct btrfs_root *root);
3845void btrfs_scrub_pause_super(struct btrfs_root *root);
3846void btrfs_scrub_continue(struct btrfs_root *root);
3847void btrfs_scrub_continue_super(struct btrfs_root *root);
3848int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3849int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
3850 struct btrfs_device *dev);
3851int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
3852 struct btrfs_scrub_progress *progress);
3853
3854
3855struct reada_control {
3856 struct btrfs_root *root;
3857 struct btrfs_key key_start;
3858 struct btrfs_key key_end;
3859 atomic_t elems;
3860 struct kref refcnt;
3861 wait_queue_head_t wait;
3862};
3863struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3864 struct btrfs_key *start, struct btrfs_key *end);
3865int btrfs_reada_wait(void *handle);
3866void btrfs_reada_detach(void *handle);
3867int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,
3868 u64 start, int err);
3869
3870
3871struct qgroup_update {
3872 struct list_head list;
3873 struct btrfs_delayed_ref_node *node;
3874 struct btrfs_delayed_extent_op *extent_op;
3875};
3876
3877int btrfs_quota_enable(struct btrfs_trans_handle *trans,
3878 struct btrfs_fs_info *fs_info);
3879int btrfs_quota_disable(struct btrfs_trans_handle *trans,
3880 struct btrfs_fs_info *fs_info);
3881int btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info);
3882void btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info);
3883int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info);
3884int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans,
3885 struct btrfs_fs_info *fs_info, u64 src, u64 dst);
3886int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans,
3887 struct btrfs_fs_info *fs_info, u64 src, u64 dst);
3888int btrfs_create_qgroup(struct btrfs_trans_handle *trans,
3889 struct btrfs_fs_info *fs_info, u64 qgroupid,
3890 char *name);
3891int btrfs_remove_qgroup(struct btrfs_trans_handle *trans,
3892 struct btrfs_fs_info *fs_info, u64 qgroupid);
3893int btrfs_limit_qgroup(struct btrfs_trans_handle *trans,
3894 struct btrfs_fs_info *fs_info, u64 qgroupid,
3895 struct btrfs_qgroup_limit *limit);
3896int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info);
3897void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info);
3898struct btrfs_delayed_extent_op;
3899int btrfs_qgroup_record_ref(struct btrfs_trans_handle *trans,
3900 struct btrfs_delayed_ref_node *node,
3901 struct btrfs_delayed_extent_op *extent_op);
3902int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
3903 struct btrfs_fs_info *fs_info,
3904 struct btrfs_delayed_ref_node *node,
3905 struct btrfs_delayed_extent_op *extent_op);
3906int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
3907 struct btrfs_fs_info *fs_info);
3908int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans,
3909 struct btrfs_fs_info *fs_info, u64 srcid, u64 objectid,
3910 struct btrfs_qgroup_inherit *inherit);
3911int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes);
3912void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes);
3913
3914void assert_qgroups_uptodate(struct btrfs_trans_handle *trans);
3915
3916static inline int is_fstree(u64 rootid)
3917{
3918 if (rootid == BTRFS_FS_TREE_OBJECTID ||
3919 (s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID)
3920 return 1;
3921 return 0;
3922}
3923
3924static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
3925{
3926 return signal_pending(current);
3927}
3928
3929
3930#endif
3931