1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2 /*
3  * Copied from kernel/include/uapi/linux/btrfs_btree.h.
4  *
5  * Only modified the header.
6  */
7 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
8 #ifndef __BTRFS_TREE_H__
9 #define __BTRFS_TREE_H__
10 
11 #include <linux/types.h>
12 
13 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
14 
15 /*
16  * The max metadata block size (node size).
17  *
18  * This limit is somewhat artificial. The memmove and tree block locking cost
19  * go up with larger node size.
20  */
21 #define BTRFS_MAX_METADATA_BLOCKSIZE 65536
22 
23 /*
24  * We can actually store much bigger names, but lets not confuse the rest
25  * of linux.
26  *
27  * btrfs_dir_item::name_len follows this limitation.
28  */
29 #define BTRFS_NAME_LEN 255
30 
31 /*
32  * Objectids start from here.
33  *
34  * Check btrfs_disk_key for the meaning of objectids.
35  */
36 
37 /*
38  * Root tree holds pointers to all of the tree roots.
39  * Without special mention, the root tree contains the root bytenr of all other
40  * trees, except the chunk tree and the log tree.
41  *
42  * The super block contains the root bytenr of this tree.
43  */
44 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
45 
46 /*
47  * Extent tree stores information about which extents are in use, and backrefs
48  * for each extent.
49  */
50 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
51 
52 /*
53  * Chunk tree stores btrfs logical address -> physical address mapping.
54  *
55  * The super block contains part of chunk tree for bootstrap, and contains
56  * the root bytenr of this tree.
57  */
58 #define BTRFS_CHUNK_TREE_OBJECTID 3ULL
59 
60 /*
61  * Device tree stores info about which areas of a given device are in use,
62  * and physical address -> btrfs logical address mapping.
63  */
64 #define BTRFS_DEV_TREE_OBJECTID 4ULL
65 
66 /* The fs tree is the first subvolume tree, storing files and directories. */
67 #define BTRFS_FS_TREE_OBJECTID 5ULL
68 
69 /* Shows the directory objectid inside the root tree. */
70 #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
71 
72 /* Csum tree holds checksums of all the data extents. */
73 #define BTRFS_CSUM_TREE_OBJECTID 7ULL
74 
75 /* Quota tree holds quota configuration and tracking. */
76 #define BTRFS_QUOTA_TREE_OBJECTID 8ULL
77 
78 /* UUID tree stores items that use the BTRFS_UUID_KEY* types. */
79 #define BTRFS_UUID_TREE_OBJECTID 9ULL
80 
81 /* Free space cache tree (v2 space cache) tracks free space in block groups. */
82 #define BTRFS_FREE_SPACE_TREE_OBJECTID 10ULL
83 
84 /* Indicates device stats in the device tree. */
85 #define BTRFS_DEV_STATS_OBJECTID 0ULL
86 
87 /* For storing balance parameters in the root tree. */
88 #define BTRFS_BALANCE_OBJECTID -4ULL
89 
90 /* Orhpan objectid for tracking unlinked/truncated files. */
91 #define BTRFS_ORPHAN_OBJECTID -5ULL
92 
93 /* Does write ahead logging to speed up fsyncs. */
94 #define BTRFS_TREE_LOG_OBJECTID -6ULL
95 #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
96 
97 /* For space balancing. */
98 #define BTRFS_TREE_RELOC_OBJECTID -8ULL
99 #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
100 
101 /* Extent checksums, shared between the csum tree and log trees. */
102 #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
103 
104 /* For storing free space cache (v1 space cache). */
105 #define BTRFS_FREE_SPACE_OBJECTID -11ULL
106 
107 /* The inode number assigned to the special inode for storing free ino cache. */
108 #define BTRFS_FREE_INO_OBJECTID -12ULL
109 
110 /* Dummy objectid represents multiple objectids. */
111 #define BTRFS_MULTIPLE_OBJECTIDS -255ULL
112 
113 /* All files have objectids in this range. */
114 #define BTRFS_FIRST_FREE_OBJECTID 256ULL
115 #define BTRFS_LAST_FREE_OBJECTID -256ULL
116 #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
117 
118 
119 /*
120  * The device items go into the chunk tree.
121  *
122  * The key is in the form
123  * (BTRFS_DEV_ITEMS_OBJECTID, BTRFS_DEV_ITEM_KEY,  <device_id>)
124  */
125 #define BTRFS_DEV_ITEMS_OBJECTID 1ULL
126 
127 #define BTRFS_BTREE_INODE_OBJECTID 1
128 
129 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
130 
131 #define BTRFS_DEV_REPLACE_DEVID 0ULL
132 
133 /*
134  * Types start from here.
135  *
136  * Check btrfs_disk_key for details about types.
137  */
138 
139 /*
140  * Inode items have the data typically returned from stat and store other
141  * info about object characteristics.
142  *
143  * There is one for every file and dir in the FS.
144  */
145 #define BTRFS_INODE_ITEM_KEY		1
146 /* reserve 2-11 close to the inode for later flexibility */
147 #define BTRFS_INODE_REF_KEY		12
148 #define BTRFS_INODE_EXTREF_KEY		13
149 #define BTRFS_XATTR_ITEM_KEY		24
150 #define BTRFS_ORPHAN_ITEM_KEY		48
151 
152 /*
153  * Dir items are the name -> inode pointers in a directory.
154  *
155  * There is one for every name in a directory.
156  */
157 #define BTRFS_DIR_LOG_ITEM_KEY  60
158 #define BTRFS_DIR_LOG_INDEX_KEY 72
159 #define BTRFS_DIR_ITEM_KEY	84
160 #define BTRFS_DIR_INDEX_KEY	96
161 
162 /* Stores info (position, size ...) about a data extent of a file */
163 #define BTRFS_EXTENT_DATA_KEY	108
164 
165 /*
166  * Extent csums are stored in a separate tree and hold csums for
167  * an entire extent on disk.
168  */
169 #define BTRFS_EXTENT_CSUM_KEY	128
170 
171 /*
172  * Root items point to tree roots.
173  *
174  * They are typically in the root tree used by the super block to find all the
175  * other trees.
176  */
177 #define BTRFS_ROOT_ITEM_KEY	132
178 
179 /*
180  * Root backrefs tie subvols and snapshots to the directory entries that
181  * reference them.
182  */
183 #define BTRFS_ROOT_BACKREF_KEY	144
184 
185 /*
186  * Root refs make a fast index for listing all of the snapshots and
187  * subvolumes referenced by a given root.  They point directly to the
188  * directory item in the root that references the subvol.
189  */
190 #define BTRFS_ROOT_REF_KEY	156
191 
192 /*
193  * Extent items are in the extent tree.
194  *
195  * These record which blocks are used, and how many references there are.
196  */
197 #define BTRFS_EXTENT_ITEM_KEY	168
198 
199 /*
200  * The same as the BTRFS_EXTENT_ITEM_KEY, except it's metadata we already know
201  * the length, so we save the level in key->offset instead of the length.
202  */
203 #define BTRFS_METADATA_ITEM_KEY	169
204 
205 #define BTRFS_TREE_BLOCK_REF_KEY	176
206 
207 #define BTRFS_EXTENT_DATA_REF_KEY	178
208 
209 #define BTRFS_EXTENT_REF_V0_KEY		180
210 
211 #define BTRFS_SHARED_BLOCK_REF_KEY	182
212 
213 #define BTRFS_SHARED_DATA_REF_KEY	184
214 
215 /*
216  * Block groups give us hints into the extent allocation trees.
217  *
218  * Stores how many free space there is in a block group.
219  */
220 #define BTRFS_BLOCK_GROUP_ITEM_KEY 192
221 
222 /*
223  * Every block group is represented in the free space tree by a free space info
224  * item, which stores some accounting information. It is keyed on
225  * (block_group_start, FREE_SPACE_INFO, block_group_length).
226  */
227 #define BTRFS_FREE_SPACE_INFO_KEY 198
228 
229 /*
230  * A free space extent tracks an extent of space that is free in a block group.
231  * It is keyed on (start, FREE_SPACE_EXTENT, length).
232  */
233 #define BTRFS_FREE_SPACE_EXTENT_KEY 199
234 
235 /*
236  * When a block group becomes very fragmented, we convert it to use bitmaps
237  * instead of extents.
238  *
239  * A free space bitmap is keyed on (start, FREE_SPACE_BITMAP, length).
240  * The corresponding item is a bitmap with (length / sectorsize) bits.
241  */
242 #define BTRFS_FREE_SPACE_BITMAP_KEY 200
243 
244 #define BTRFS_DEV_EXTENT_KEY	204
245 #define BTRFS_DEV_ITEM_KEY	216
246 #define BTRFS_CHUNK_ITEM_KEY	228
247 
248 /*
249  * Records the overall state of the qgroups.
250  *
251  * There's only one instance of this key present,
252  * (0, BTRFS_QGROUP_STATUS_KEY, 0)
253  */
254 #define BTRFS_QGROUP_STATUS_KEY         240
255 /*
256  * Records the currently used space of the qgroup.
257  *
258  * One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid).
259  */
260 #define BTRFS_QGROUP_INFO_KEY           242
261 
262 /*
263  * Contains the user configured limits for the qgroup.
264  *
265  * One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid).
266  */
267 #define BTRFS_QGROUP_LIMIT_KEY          244
268 
269 /*
270  * Records the child-parent relationship of qgroups. For
271  * each relation, 2 keys are present:
272  * (childid, BTRFS_QGROUP_RELATION_KEY, parentid)
273  * (parentid, BTRFS_QGROUP_RELATION_KEY, childid)
274  */
275 #define BTRFS_QGROUP_RELATION_KEY       246
276 
277 /* Obsolete name, see BTRFS_TEMPORARY_ITEM_KEY. */
278 #define BTRFS_BALANCE_ITEM_KEY	248
279 
280 /*
281  * The key type for tree items that are stored persistently, but do not need to
282  * exist for extended period of time. The items can exist in any tree.
283  *
284  * [subtype, BTRFS_TEMPORARY_ITEM_KEY, data]
285  *
286  * Existing items:
287  *
288  * - balance status item
289  *   (BTRFS_BALANCE_OBJECTID, BTRFS_TEMPORARY_ITEM_KEY, 0)
290  */
291 #define BTRFS_TEMPORARY_ITEM_KEY	248
292 
293 /* Obsolete name, see BTRFS_PERSISTENT_ITEM_KEY */
294 #define BTRFS_DEV_STATS_KEY		249
295 
296 /*
297  * The key type for tree items that are stored persistently and usually exist
298  * for a long period, eg. filesystem lifetime. The item kinds can be status
299  * information, stats or preference values. The item can exist in any tree.
300  *
301  * [subtype, BTRFS_PERSISTENT_ITEM_KEY, data]
302  *
303  * Existing items:
304  *
305  * - device statistics, store IO stats in the device tree, one key for all
306  *   stats
307  *   (BTRFS_DEV_STATS_OBJECTID, BTRFS_DEV_STATS_KEY, 0)
308  */
309 #define BTRFS_PERSISTENT_ITEM_KEY	249
310 
311 /*
312  * Persistently stores the device replace state in the device tree.
313  *
314  * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).
315  */
316 #define BTRFS_DEV_REPLACE_KEY	250
317 
318 /*
319  * Stores items that allow to quickly map UUIDs to something else.
320  *
321  * These items are part of the filesystem UUID tree.
322  * The key is built like this:
323  * (UUID_upper_64_bits, BTRFS_UUID_KEY*, UUID_lower_64_bits).
324  */
325 #define BTRFS_UUID_KEY_SUBVOL	251	/* for UUIDs assigned to subvols */
326 #define BTRFS_UUID_KEY_RECEIVED_SUBVOL	252	/* for UUIDs assigned to
327 						 * received subvols */
328 
329 /*
330  * String items are for debugging.
331  *
332  * They just store a short string of data in the FS.
333  */
334 #define BTRFS_STRING_ITEM_KEY	253
335 
336 
337 
338 /* 32 bytes in various csum fields */
339 #define BTRFS_CSUM_SIZE 32
340 
341 /* Csum types */
342 enum btrfs_csum_type {
343 	BTRFS_CSUM_TYPE_CRC32	= 0,
344 	BTRFS_CSUM_TYPE_XXHASH	= 1,
345 	BTRFS_CSUM_TYPE_SHA256	= 2,
346 	BTRFS_CSUM_TYPE_BLAKE2	= 3,
347 };
348 
349 /*
350  * Flags definitions for directory entry item type.
351  *
352  * Used by:
353  * struct btrfs_dir_item.type
354  *
355  * Values 0..7 must match common file type values in fs_types.h.
356  */
357 #define BTRFS_FT_UNKNOWN	0
358 #define BTRFS_FT_REG_FILE	1
359 #define BTRFS_FT_DIR		2
360 #define BTRFS_FT_CHRDEV		3
361 #define BTRFS_FT_BLKDEV		4
362 #define BTRFS_FT_FIFO		5
363 #define BTRFS_FT_SOCK		6
364 #define BTRFS_FT_SYMLINK	7
365 #define BTRFS_FT_XATTR		8
366 #define BTRFS_FT_MAX		9
367 
368 #define BTRFS_FSID_SIZE 16
369 #define BTRFS_UUID_SIZE 16
370 
371 /*
372  * The key defines the order in the tree, and so it also defines (optimal)
373  * block layout.
374  *
375  * Objectid and offset are interpreted based on type.
376  * While normally for objectid, it either represents a root number, or an
377  * inode number.
378  *
379  * Type tells us things about the object, and is a kind of stream selector.
380  * Check the following URL for full references about btrfs_disk_key/btrfs_key:
381  * https://btrfs.wiki.kernel.org/index.php/Btree_Items
382  *
383  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
384  * in cpu native order.  Otherwise they are identical and their sizes
385  * should be the same (ie both packed)
386  */
387 struct btrfs_disk_key {
388 	__le64 objectid;
389 	__u8 type;
390 	__le64 offset;
391 } __attribute__ ((__packed__));
392 
393 struct btrfs_key {
394 	__u64 objectid;
395 	__u8 type;
396 	__u64 offset;
397 } __attribute__ ((__packed__));
398 
399 struct btrfs_dev_item {
400 	/* The internal btrfs device id */
401 	__le64 devid;
402 
403 	/* Size of the device */
404 	__le64 total_bytes;
405 
406 	/* Bytes used */
407 	__le64 bytes_used;
408 
409 	/* Optimal io alignment for this device */
410 	__le32 io_align;
411 
412 	/* Optimal io width for this device */
413 	__le32 io_width;
414 
415 	/* Minimal io size for this device */
416 	__le32 sector_size;
417 
418 	/* Type and info about this device */
419 	__le64 type;
420 
421 	/* Expected generation for this device */
422 	__le64 generation;
423 
424 	/*
425 	 * Starting byte of this partition on the device,
426 	 * to allow for stripe alignment in the future.
427 	 */
428 	__le64 start_offset;
429 
430 	/* Grouping information for allocation decisions */
431 	__le32 dev_group;
432 
433 	/* Optimal seek speed 0-100 where 100 is fastest */
434 	__u8 seek_speed;
435 
436 	/* Optimal bandwidth 0-100 where 100 is fastest */
437 	__u8 bandwidth;
438 
439 	/* Btrfs generated uuid for this device */
440 	__u8 uuid[BTRFS_UUID_SIZE];
441 
442 	/* UUID of FS who owns this device */
443 	__u8 fsid[BTRFS_UUID_SIZE];
444 } __attribute__ ((__packed__));
445 
446 struct btrfs_stripe {
447 	__le64 devid;
448 	__le64 offset;
449 	__u8 dev_uuid[BTRFS_UUID_SIZE];
450 } __attribute__ ((__packed__));
451 
452 struct btrfs_chunk {
453 	/* Size of this chunk in bytes */
454 	__le64 length;
455 
456 	/* Objectid of the root referencing this chunk */
457 	__le64 owner;
458 
459 	__le64 stripe_len;
460 	__le64 type;
461 
462 	/* Optimal io alignment for this chunk */
463 	__le32 io_align;
464 
465 	/* Optimal io width for this chunk */
466 	__le32 io_width;
467 
468 	/* Minimal io size for this chunk */
469 	__le32 sector_size;
470 
471 	/*
472 	 * 2^16 stripes is quite a lot, a second limit is the size of a single
473 	 * item in the btree.
474 	 */
475 	__le16 num_stripes;
476 
477 	/* Sub stripes only matter for raid10 */
478 	__le16 sub_stripes;
479 	struct btrfs_stripe stripe;
480 	/* additional stripes go here */
481 } __attribute__ ((__packed__));
482 
483 #define BTRFS_FREE_SPACE_EXTENT	1
484 #define BTRFS_FREE_SPACE_BITMAP	2
485 
486 struct btrfs_free_space_entry {
487 	__le64 offset;
488 	__le64 bytes;
489 	__u8 type;
490 } __attribute__ ((__packed__));
491 
492 struct btrfs_free_space_header {
493 	struct btrfs_disk_key location;
494 	__le64 generation;
495 	__le64 num_entries;
496 	__le64 num_bitmaps;
497 } __attribute__ ((__packed__));
498 
499 #define BTRFS_HEADER_FLAG_WRITTEN	(1ULL << 0)
500 #define BTRFS_HEADER_FLAG_RELOC		(1ULL << 1)
501 
502 /* Super block flags */
503 /* Errors detected */
504 #define BTRFS_SUPER_FLAG_ERROR		(1ULL << 2)
505 
506 #define BTRFS_SUPER_FLAG_SEEDING	(1ULL << 32)
507 #define BTRFS_SUPER_FLAG_METADUMP	(1ULL << 33)
508 #define BTRFS_SUPER_FLAG_METADUMP_V2	(1ULL << 34)
509 #define BTRFS_SUPER_FLAG_CHANGING_FSID	(1ULL << 35)
510 #define BTRFS_SUPER_FLAG_CHANGING_FSID_V2 (1ULL << 36)
511 
512 
513 /*
514  * Items in the extent tree are used to record the objectid of the
515  * owner of the block and the number of references.
516  */
517 struct btrfs_extent_item {
518 	__le64 refs;
519 	__le64 generation;
520 	__le64 flags;
521 } __attribute__ ((__packed__));
522 
523 struct btrfs_extent_item_v0 {
524 	__le32 refs;
525 } __attribute__ ((__packed__));
526 
527 
528 #define BTRFS_EXTENT_FLAG_DATA		(1ULL << 0)
529 #define BTRFS_EXTENT_FLAG_TREE_BLOCK	(1ULL << 1)
530 
531 /* Use full backrefs for extent pointers in the block */
532 #define BTRFS_BLOCK_FLAG_FULL_BACKREF	(1ULL << 8)
533 
534 /*
535  * This flag is only used internally by scrub and may be changed at any time
536  * it is only declared here to avoid collisions.
537  */
538 #define BTRFS_EXTENT_FLAG_SUPER		(1ULL << 48)
539 
540 struct btrfs_tree_block_info {
541 	struct btrfs_disk_key key;
542 	__u8 level;
543 } __attribute__ ((__packed__));
544 
545 struct btrfs_extent_data_ref {
546 	__le64 root;
547 	__le64 objectid;
548 	__le64 offset;
549 	__le32 count;
550 } __attribute__ ((__packed__));
551 
552 struct btrfs_shared_data_ref {
553 	__le32 count;
554 } __attribute__ ((__packed__));
555 
556 struct btrfs_extent_inline_ref {
557 	__u8 type;
558 	__le64 offset;
559 } __attribute__ ((__packed__));
560 
561 /* Old style backrefs item */
562 struct btrfs_extent_ref_v0 {
563 	__le64 root;
564 	__le64 generation;
565 	__le64 objectid;
566 	__le32 count;
567 } __attribute__ ((__packed__));
568 
569 
570 /* Dev extents record used space on individual devices.
571  *
572  * The owner field points back to the chunk allocation mapping tree that
573  * allocated the extent.
574  * The chunk tree uuid field is a way to double check the owner.
575  */
576 struct btrfs_dev_extent {
577 	__le64 chunk_tree;
578 	__le64 chunk_objectid;
579 	__le64 chunk_offset;
580 	__le64 length;
581 	__u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
582 } __attribute__ ((__packed__));
583 
584 struct btrfs_inode_ref {
585 	__le64 index;
586 	__le16 name_len;
587 	/* Name goes here */
588 } __attribute__ ((__packed__));
589 
590 struct btrfs_inode_extref {
591 	__le64 parent_objectid;
592 	__le64 index;
593 	__le16 name_len;
594 	__u8   name[0];
595 	/* Name goes here */
596 } __attribute__ ((__packed__));
597 
598 struct btrfs_timespec {
599 	__le64 sec;
600 	__le32 nsec;
601 } __attribute__ ((__packed__));
602 
603 /* Inode flags */
604 #define BTRFS_INODE_NODATASUM		(1 << 0)
605 #define BTRFS_INODE_NODATACOW		(1 << 1)
606 #define BTRFS_INODE_READONLY		(1 << 2)
607 #define BTRFS_INODE_NOCOMPRESS		(1 << 3)
608 #define BTRFS_INODE_PREALLOC		(1 << 4)
609 #define BTRFS_INODE_SYNC		(1 << 5)
610 #define BTRFS_INODE_IMMUTABLE		(1 << 6)
611 #define BTRFS_INODE_APPEND		(1 << 7)
612 #define BTRFS_INODE_NODUMP		(1 << 8)
613 #define BTRFS_INODE_NOATIME		(1 << 9)
614 #define BTRFS_INODE_DIRSYNC		(1 << 10)
615 #define BTRFS_INODE_COMPRESS		(1 << 11)
616 
617 #define BTRFS_INODE_ROOT_ITEM_INIT	(1 << 31)
618 
619 #define BTRFS_INODE_FLAG_MASK						\
620 	(BTRFS_INODE_NODATASUM |					\
621 	 BTRFS_INODE_NODATACOW |					\
622 	 BTRFS_INODE_READONLY |						\
623 	 BTRFS_INODE_NOCOMPRESS |					\
624 	 BTRFS_INODE_PREALLOC |						\
625 	 BTRFS_INODE_SYNC |						\
626 	 BTRFS_INODE_IMMUTABLE |					\
627 	 BTRFS_INODE_APPEND |						\
628 	 BTRFS_INODE_NODUMP |						\
629 	 BTRFS_INODE_NOATIME |						\
630 	 BTRFS_INODE_DIRSYNC |						\
631 	 BTRFS_INODE_COMPRESS |						\
632 	 BTRFS_INODE_ROOT_ITEM_INIT)
633 
634 struct btrfs_inode_item {
635 	/* Nfs style generation number */
636 	__le64 generation;
637 	/* Transid that last touched this inode */
638 	__le64 transid;
639 	__le64 size;
640 	__le64 nbytes;
641 	__le64 block_group;
642 	__le32 nlink;
643 	__le32 uid;
644 	__le32 gid;
645 	__le32 mode;
646 	__le64 rdev;
647 	__le64 flags;
648 
649 	/* Modification sequence number for NFS */
650 	__le64 sequence;
651 
652 	/*
653 	 * A little future expansion, for more than this we can just grow the
654 	 * inode item and version it
655 	 */
656 	__le64 reserved[4];
657 	struct btrfs_timespec atime;
658 	struct btrfs_timespec ctime;
659 	struct btrfs_timespec mtime;
660 	struct btrfs_timespec otime;
661 } __attribute__ ((__packed__));
662 
663 struct btrfs_dir_log_item {
664 	__le64 end;
665 } __attribute__ ((__packed__));
666 
667 struct btrfs_dir_item {
668 	struct btrfs_disk_key location;
669 	__le64 transid;
670 	__le16 data_len;
671 	__le16 name_len;
672 	__u8 type;
673 } __attribute__ ((__packed__));
674 
675 #define BTRFS_ROOT_SUBVOL_RDONLY	(1ULL << 0)
676 
677 /*
678  * Internal in-memory flag that a subvolume has been marked for deletion but
679  * still visible as a directory
680  */
681 #define BTRFS_ROOT_SUBVOL_DEAD		(1ULL << 48)
682 
683 struct btrfs_root_item {
684 	struct btrfs_inode_item inode;
685 	__le64 generation;
686 	__le64 root_dirid;
687 	__le64 bytenr;
688 	__le64 byte_limit;
689 	__le64 bytes_used;
690 	__le64 last_snapshot;
691 	__le64 flags;
692 	__le32 refs;
693 	struct btrfs_disk_key drop_progress;
694 	__u8 drop_level;
695 	__u8 level;
696 
697 	/*
698 	 * The following fields appear after subvol_uuids+subvol_times
699 	 * were introduced.
700 	 */
701 
702 	/*
703 	 * This generation number is used to test if the new fields are valid
704 	 * and up to date while reading the root item. Every time the root item
705 	 * is written out, the "generation" field is copied into this field. If
706 	 * anyone ever mounted the fs with an older kernel, we will have
707 	 * mismatching generation values here and thus must invalidate the
708 	 * new fields. See btrfs_update_root and btrfs_find_last_root for
709 	 * details.
710 	 * The offset of generation_v2 is also used as the start for the memset
711 	 * when invalidating the fields.
712 	 */
713 	__le64 generation_v2;
714 	__u8 uuid[BTRFS_UUID_SIZE];
715 	__u8 parent_uuid[BTRFS_UUID_SIZE];
716 	__u8 received_uuid[BTRFS_UUID_SIZE];
717 	__le64 ctransid; /* Updated when an inode changes */
718 	__le64 otransid; /* Trans when created */
719 	__le64 stransid; /* Trans when sent. Non-zero for received subvol. */
720 	__le64 rtransid; /* Trans when received. Non-zero for received subvol.*/
721 	struct btrfs_timespec ctime;
722 	struct btrfs_timespec otime;
723 	struct btrfs_timespec stime;
724 	struct btrfs_timespec rtime;
725 	__le64 reserved[8]; /* For future */
726 } __attribute__ ((__packed__));
727 
728 /* This is used for both forward and backward root refs */
729 struct btrfs_root_ref {
730 	__le64 dirid;
731 	__le64 sequence;
732 	__le16 name_len;
733 } __attribute__ ((__packed__));
734 
735 struct btrfs_disk_balance_args {
736 	/*
737 	 * Profiles to operate on.
738 	 *
739 	 * SINGLE is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE.
740 	 */
741 	__le64 profiles;
742 
743 	/*
744 	 * Usage filter
745 	 * BTRFS_BALANCE_ARGS_USAGE with a single value means '0..N'
746 	 * BTRFS_BALANCE_ARGS_USAGE_RANGE - range syntax, min..max
747 	 */
748 	union {
749 		__le64 usage;
750 		struct {
751 			__le32 usage_min;
752 			__le32 usage_max;
753 		};
754 	};
755 
756 	/* Devid filter */
757 	__le64 devid;
758 
759 	/* Devid subset filter [pstart..pend) */
760 	__le64 pstart;
761 	__le64 pend;
762 
763 	/* Btrfs virtual address space subset filter [vstart..vend) */
764 	__le64 vstart;
765 	__le64 vend;
766 
767 	/*
768 	 * Profile to convert to.
769 	 *
770 	 * SINGLE is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE.
771 	 */
772 	__le64 target;
773 
774 	/* BTRFS_BALANCE_ARGS_* */
775 	__le64 flags;
776 
777 	/*
778 	 * BTRFS_BALANCE_ARGS_LIMIT with value 'limit'.
779 	 * BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum
780 	 * and maximum.
781 	 */
782 	union {
783 		__le64 limit;
784 		struct {
785 			__le32 limit_min;
786 			__le32 limit_max;
787 		};
788 	};
789 
790 	/*
791 	 * Process chunks that cross stripes_min..stripes_max devices,
792 	 * BTRFS_BALANCE_ARGS_STRIPES_RANGE.
793 	 */
794 	__le32 stripes_min;
795 	__le32 stripes_max;
796 
797 	__le64 unused[6];
798 } __attribute__ ((__packed__));
799 
800 /*
801  * Stores balance parameters to disk so that balance can be properly
802  * resumed after crash or unmount.
803  */
804 struct btrfs_balance_item {
805 	/* BTRFS_BALANCE_* */
806 	__le64 flags;
807 
808 	struct btrfs_disk_balance_args data;
809 	struct btrfs_disk_balance_args meta;
810 	struct btrfs_disk_balance_args sys;
811 
812 	__le64 unused[4];
813 } __attribute__ ((__packed__));
814 
815 enum {
816 	BTRFS_FILE_EXTENT_INLINE   = 0,
817 	BTRFS_FILE_EXTENT_REG      = 1,
818 	BTRFS_FILE_EXTENT_PREALLOC = 2,
819 	BTRFS_NR_FILE_EXTENT_TYPES = 3,
820 };
821 
822 enum btrfs_compression_type {
823 	BTRFS_COMPRESS_NONE  = 0,
824 	BTRFS_COMPRESS_ZLIB  = 1,
825 	BTRFS_COMPRESS_LZO   = 2,
826 	BTRFS_COMPRESS_ZSTD  = 3,
827 	BTRFS_NR_COMPRESS_TYPES = 4,
828 };
829 
830 struct btrfs_file_extent_item {
831 	/* Transaction id that created this extent */
832 	__le64 generation;
833 	/*
834 	 * Max number of bytes to hold this extent in ram.
835 	 *
836 	 * When we split a compressed extent we can't know how big each of the
837 	 * resulting pieces will be.  So, this is an upper limit on the size of
838 	 * the extent in ram instead of an exact limit.
839 	 */
840 	__le64 ram_bytes;
841 
842 	/*
843 	 * 32 bits for the various ways we might encode the data,
844 	 * including compression and encryption.  If any of these
845 	 * are set to something a given disk format doesn't understand
846 	 * it is treated like an incompat flag for reading and writing,
847 	 * but not for stat.
848 	 */
849 	__u8 compression;
850 	__u8 encryption;
851 	__le16 other_encoding; /* Spare for later use */
852 
853 	/* Are we inline data or a real extent? */
854 	__u8 type;
855 
856 	/*
857 	 * Disk space consumed by the extent, checksum blocks are not included
858 	 * in these numbers
859 	 *
860 	 * At this offset in the structure, the inline extent data start.
861 	 */
862 	__le64 disk_bytenr;
863 	__le64 disk_num_bytes;
864 
865 	/*
866 	 * The logical offset inside the file extent.
867 	 *
868 	 * This allows a file extent to point into the middle of an existing
869 	 * extent on disk, sharing it between two snapshots (useful if some
870 	 * bytes in the middle of the extent have changed).
871 	 */
872 	__le64 offset;
873 
874 	/*
875 	 * The logical number of bytes this file extent is referencing (no
876 	 * csums included).
877 	 *
878 	 * This always reflects the size uncompressed and without encoding.
879 	 */
880 	__le64 num_bytes;
881 
882 } __attribute__ ((__packed__));
883 
884 struct btrfs_csum_item {
885 	__u8 csum;
886 } __attribute__ ((__packed__));
887 
888 enum btrfs_dev_stat_values {
889 	/* Disk I/O failure stats */
890 	BTRFS_DEV_STAT_WRITE_ERRS, /* EIO or EREMOTEIO from lower layers */
891 	BTRFS_DEV_STAT_READ_ERRS, /* EIO or EREMOTEIO from lower layers */
892 	BTRFS_DEV_STAT_FLUSH_ERRS, /* EIO or EREMOTEIO from lower layers */
893 
894 	/* Stats for indirect indications for I/O failures */
895 	BTRFS_DEV_STAT_CORRUPTION_ERRS, /* Checksum error, bytenr error or
896 					 * contents is illegal: this is an
897 					 * indication that the block was damaged
898 					 * during read or write, or written to
899 					 * wrong location or read from wrong
900 					 * location */
901 	BTRFS_DEV_STAT_GENERATION_ERRS, /* An indication that blocks have not
902 					 * been written */
903 
904 	BTRFS_DEV_STAT_VALUES_MAX
905 };
906 
907 struct btrfs_dev_stats_item {
908 	/*
909 	 * Grow this item struct at the end for future enhancements and keep
910 	 * the existing values unchanged.
911 	 */
912 	__le64 values[BTRFS_DEV_STAT_VALUES_MAX];
913 } __attribute__ ((__packed__));
914 
915 #define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS	0
916 #define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID	1
917 
918 struct btrfs_dev_replace_item {
919 	/*
920 	 * Grow this item struct at the end for future enhancements and keep
921 	 * the existing values unchanged.
922 	 */
923 	__le64 src_devid;
924 	__le64 cursor_left;
925 	__le64 cursor_right;
926 	__le64 cont_reading_from_srcdev_mode;
927 
928 	__le64 replace_state;
929 	__le64 time_started;
930 	__le64 time_stopped;
931 	__le64 num_write_errors;
932 	__le64 num_uncorrectable_read_errors;
933 } __attribute__ ((__packed__));
934 
935 /* Different types of block groups (and chunks) */
936 #define BTRFS_BLOCK_GROUP_DATA		(1ULL << 0)
937 #define BTRFS_BLOCK_GROUP_SYSTEM	(1ULL << 1)
938 #define BTRFS_BLOCK_GROUP_METADATA	(1ULL << 2)
939 #define BTRFS_BLOCK_GROUP_RAID0		(1ULL << 3)
940 #define BTRFS_BLOCK_GROUP_RAID1		(1ULL << 4)
941 #define BTRFS_BLOCK_GROUP_DUP		(1ULL << 5)
942 #define BTRFS_BLOCK_GROUP_RAID10	(1ULL << 6)
943 #define BTRFS_BLOCK_GROUP_RAID5         (1ULL << 7)
944 #define BTRFS_BLOCK_GROUP_RAID6         (1ULL << 8)
945 #define BTRFS_BLOCK_GROUP_RAID1C3       (1ULL << 9)
946 #define BTRFS_BLOCK_GROUP_RAID1C4       (1ULL << 10)
947 #define BTRFS_BLOCK_GROUP_RESERVED	(BTRFS_AVAIL_ALLOC_BIT_SINGLE | \
948 					 BTRFS_SPACE_INFO_GLOBAL_RSV)
949 
950 enum btrfs_raid_types {
951 	BTRFS_RAID_RAID10,
952 	BTRFS_RAID_RAID1,
953 	BTRFS_RAID_DUP,
954 	BTRFS_RAID_RAID0,
955 	BTRFS_RAID_SINGLE,
956 	BTRFS_RAID_RAID5,
957 	BTRFS_RAID_RAID6,
958 	BTRFS_RAID_RAID1C3,
959 	BTRFS_RAID_RAID1C4,
960 	BTRFS_NR_RAID_TYPES
961 };
962 
963 #define BTRFS_BLOCK_GROUP_TYPE_MASK	(BTRFS_BLOCK_GROUP_DATA |    \
964 					 BTRFS_BLOCK_GROUP_SYSTEM |  \
965 					 BTRFS_BLOCK_GROUP_METADATA)
966 
967 #define BTRFS_BLOCK_GROUP_PROFILE_MASK	(BTRFS_BLOCK_GROUP_RAID0 |   \
968 					 BTRFS_BLOCK_GROUP_RAID1 |   \
969 					 BTRFS_BLOCK_GROUP_RAID1C3 | \
970 					 BTRFS_BLOCK_GROUP_RAID1C4 | \
971 					 BTRFS_BLOCK_GROUP_RAID5 |   \
972 					 BTRFS_BLOCK_GROUP_RAID6 |   \
973 					 BTRFS_BLOCK_GROUP_DUP |     \
974 					 BTRFS_BLOCK_GROUP_RAID10)
975 #define BTRFS_BLOCK_GROUP_RAID56_MASK	(BTRFS_BLOCK_GROUP_RAID5 |   \
976 					 BTRFS_BLOCK_GROUP_RAID6)
977 
978 #define BTRFS_BLOCK_GROUP_RAID1_MASK	(BTRFS_BLOCK_GROUP_RAID1 |   \
979 					 BTRFS_BLOCK_GROUP_RAID1C3 | \
980 					 BTRFS_BLOCK_GROUP_RAID1C4)
981 
982 /*
983  * We need a bit for restriper to be able to tell when chunks of type
984  * SINGLE are available.  This "extended" profile format is used in
985  * fs_info->avail_*_alloc_bits (in-memory) and balance item fields
986  * (on-disk).  The corresponding on-disk bit in chunk.type is reserved
987  * to avoid remappings between two formats in future.
988  */
989 #define BTRFS_AVAIL_ALLOC_BIT_SINGLE	(1ULL << 48)
990 
991 /*
992  * A fake block group type that is used to communicate global block reserve
993  * size to userspace via the SPACE_INFO ioctl.
994  */
995 #define BTRFS_SPACE_INFO_GLOBAL_RSV	(1ULL << 49)
996 
997 #define BTRFS_EXTENDED_PROFILE_MASK	(BTRFS_BLOCK_GROUP_PROFILE_MASK | \
998 					 BTRFS_AVAIL_ALLOC_BIT_SINGLE)
999 
chunk_to_extended(__u64 flags)1000 static inline __u64 chunk_to_extended(__u64 flags)
1001 {
1002 	if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)
1003 		flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1004 
1005 	return flags;
1006 }
extended_to_chunk(__u64 flags)1007 static inline __u64 extended_to_chunk(__u64 flags)
1008 {
1009 	return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1010 }
1011 
1012 struct btrfs_block_group_item {
1013 	__le64 used;
1014 	__le64 chunk_objectid;
1015 	__le64 flags;
1016 } __attribute__ ((__packed__));
1017 
1018 struct btrfs_free_space_info {
1019 	__le32 extent_count;
1020 	__le32 flags;
1021 } __attribute__ ((__packed__));
1022 
1023 #define BTRFS_FREE_SPACE_USING_BITMAPS (1ULL << 0)
1024 
1025 #define BTRFS_QGROUP_LEVEL_SHIFT		48
btrfs_qgroup_level(__u64 qgroupid)1026 static inline __u64 btrfs_qgroup_level(__u64 qgroupid)
1027 {
1028 	return qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT;
1029 }
1030 
1031 /* Is subvolume quota turned on? */
1032 #define BTRFS_QGROUP_STATUS_FLAG_ON		(1ULL << 0)
1033 
1034 /* Is qgroup rescan running? */
1035 #define BTRFS_QGROUP_STATUS_FLAG_RESCAN		(1ULL << 1)
1036 
1037 /*
1038  * Some qgroup entries are known to be out of date, either because the
1039  * configuration has changed in a way that makes a rescan necessary, or
1040  * because the fs has been mounted with a non-qgroup-aware version.
1041  */
1042 #define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT	(1ULL << 2)
1043 
1044 #define BTRFS_QGROUP_STATUS_VERSION        1
1045 
1046 struct btrfs_qgroup_status_item {
1047 	__le64 version;
1048 	/*
1049 	 * The generation is updated during every commit. As older
1050 	 * versions of btrfs are not aware of qgroups, it will be
1051 	 * possible to detect inconsistencies by checking the
1052 	 * generation on mount time.
1053 	 */
1054 	__le64 generation;
1055 
1056 	/* Flag definitions see above */
1057 	__le64 flags;
1058 
1059 	/*
1060 	 * Only used during scanning to record the progress of the scan.
1061 	 * It contains a logical address.
1062 	 */
1063 	__le64 rescan;
1064 } __attribute__ ((__packed__));
1065 
1066 struct btrfs_qgroup_info_item {
1067 	__le64 generation;
1068 	__le64 rfer;
1069 	__le64 rfer_cmpr;
1070 	__le64 excl;
1071 	__le64 excl_cmpr;
1072 } __attribute__ ((__packed__));
1073 
1074 /*
1075  * Flags definition for qgroup limits
1076  *
1077  * Used by:
1078  * struct btrfs_qgroup_limit.flags
1079  * struct btrfs_qgroup_limit_item.flags
1080  */
1081 #define BTRFS_QGROUP_LIMIT_MAX_RFER	(1ULL << 0)
1082 #define BTRFS_QGROUP_LIMIT_MAX_EXCL	(1ULL << 1)
1083 #define BTRFS_QGROUP_LIMIT_RSV_RFER	(1ULL << 2)
1084 #define BTRFS_QGROUP_LIMIT_RSV_EXCL	(1ULL << 3)
1085 #define BTRFS_QGROUP_LIMIT_RFER_CMPR	(1ULL << 4)
1086 #define BTRFS_QGROUP_LIMIT_EXCL_CMPR	(1ULL << 5)
1087 
1088 struct btrfs_qgroup_limit_item {
1089 	/* Only updated when any of the other values change. */
1090 	__le64 flags;
1091 	__le64 max_rfer;
1092 	__le64 max_excl;
1093 	__le64 rsv_rfer;
1094 	__le64 rsv_excl;
1095 } __attribute__ ((__packed__));
1096 
1097 /*
1098  * Just in case we somehow lose the roots and are not able to mount,
1099  * we store an array of the roots from previous transactions in the super.
1100  */
1101 #define BTRFS_NUM_BACKUP_ROOTS 4
1102 struct btrfs_root_backup {
1103 	__le64 tree_root;
1104 	__le64 tree_root_gen;
1105 
1106 	__le64 chunk_root;
1107 	__le64 chunk_root_gen;
1108 
1109 	__le64 extent_root;
1110 	__le64 extent_root_gen;
1111 
1112 	__le64 fs_root;
1113 	__le64 fs_root_gen;
1114 
1115 	__le64 dev_root;
1116 	__le64 dev_root_gen;
1117 
1118 	__le64 csum_root;
1119 	__le64 csum_root_gen;
1120 
1121 	__le64 total_bytes;
1122 	__le64 bytes_used;
1123 	__le64 num_devices;
1124 	/* future */
1125 	__le64 unused_64[4];
1126 
1127 	u8 tree_root_level;
1128 	u8 chunk_root_level;
1129 	u8 extent_root_level;
1130 	u8 fs_root_level;
1131 	u8 dev_root_level;
1132 	u8 csum_root_level;
1133 	/* future and to align */
1134 	u8 unused_8[10];
1135 } __attribute__ ((__packed__));
1136 
1137 /*
1138  * This is a very generous portion of the super block, giving us room to
1139  * translate 14 chunks with 3 stripes each.
1140  */
1141 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
1142 
1143 #define BTRFS_LABEL_SIZE 256
1144 
1145 /* The super block basically lists the main trees of the FS. */
1146 struct btrfs_super_block {
1147 	/* The first 4 fields must match struct btrfs_header */
1148 	u8 csum[BTRFS_CSUM_SIZE];
1149 	/* FS specific UUID, visible to user */
1150 	u8 fsid[BTRFS_FSID_SIZE];
1151 	__le64 bytenr; /* this block number */
1152 	__le64 flags;
1153 
1154 	/* Allowed to be different from the btrfs_header from here own down. */
1155 	__le64 magic;
1156 	__le64 generation;
1157 	__le64 root;
1158 	__le64 chunk_root;
1159 	__le64 log_root;
1160 
1161 	/* This will help find the new super based on the log root. */
1162 	__le64 log_root_transid;
1163 	__le64 total_bytes;
1164 	__le64 bytes_used;
1165 	__le64 root_dir_objectid;
1166 	__le64 num_devices;
1167 	__le32 sectorsize;
1168 	__le32 nodesize;
1169 	__le32 __unused_leafsize;
1170 	__le32 stripesize;
1171 	__le32 sys_chunk_array_size;
1172 	__le64 chunk_root_generation;
1173 	__le64 compat_flags;
1174 	__le64 compat_ro_flags;
1175 	__le64 incompat_flags;
1176 	__le16 csum_type;
1177 	u8 root_level;
1178 	u8 chunk_root_level;
1179 	u8 log_root_level;
1180 	struct btrfs_dev_item dev_item;
1181 
1182 	char label[BTRFS_LABEL_SIZE];
1183 
1184 	__le64 cache_generation;
1185 	__le64 uuid_tree_generation;
1186 
1187 	/* The UUID written into btree blocks */
1188 	u8 metadata_uuid[BTRFS_FSID_SIZE];
1189 
1190 	/* Future expansion */
1191 	__le64 reserved[28];
1192 	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
1193 	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
1194 } __attribute__ ((__packed__));
1195 
1196 /*
1197  * Feature flags
1198  *
1199  * Used by:
1200  * struct btrfs_super_block::(compat|compat_ro|incompat)_flags
1201  * struct btrfs_ioctl_feature_flags
1202  */
1203 #define BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE		(1ULL << 0)
1204 
1205 /*
1206  * Older kernels (< 4.9) on big-endian systems produced broken free space tree
1207  * bitmaps, and btrfs-progs also used to corrupt the free space tree (versions
1208  * < 4.7.3).  If this bit is clear, then the free space tree cannot be trusted.
1209  * btrfs-progs can also intentionally clear this bit to ask the kernel to
1210  * rebuild the free space tree, however this might not work on older kernels
1211  * that do not know about this bit. If not sure, clear the cache manually on
1212  * first mount when booting older kernel versions.
1213  */
1214 #define BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID	(1ULL << 1)
1215 
1216 #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF	(1ULL << 0)
1217 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(1ULL << 1)
1218 #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS	(1ULL << 2)
1219 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO	(1ULL << 3)
1220 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD	(1ULL << 4)
1221 
1222 /*
1223  * Older kernels tried to do bigger metadata blocks, but the
1224  * code was pretty buggy.  Lets not let them try anymore.
1225  */
1226 #define BTRFS_FEATURE_INCOMPAT_BIG_METADATA	(1ULL << 5)
1227 
1228 #define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF	(1ULL << 6)
1229 #define BTRFS_FEATURE_INCOMPAT_RAID56		(1ULL << 7)
1230 #define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA	(1ULL << 8)
1231 #define BTRFS_FEATURE_INCOMPAT_NO_HOLES		(1ULL << 9)
1232 #define BTRFS_FEATURE_INCOMPAT_METADATA_UUID	(1ULL << 10)
1233 #define BTRFS_FEATURE_INCOMPAT_RAID1C34		(1ULL << 11)
1234 
1235 /*
1236  * Compat flags that we support.
1237  *
1238  * If any incompat flags are set other than the ones specified below then we
1239  * will fail to mount.
1240  */
1241 #define BTRFS_FEATURE_COMPAT_SUPP		0ULL
1242 #define BTRFS_FEATURE_COMPAT_SAFE_SET		0ULL
1243 #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR		0ULL
1244 
1245 #define BTRFS_FEATURE_COMPAT_RO_SUPP			\
1246 	(BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |	\
1247 	 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
1248 
1249 #define BTRFS_FEATURE_COMPAT_RO_SAFE_SET	0ULL
1250 #define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR	0ULL
1251 
1252 #define BTRFS_FEATURE_INCOMPAT_SUPP			\
1253 	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\
1254 	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\
1255 	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |		\
1256 	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
1257 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
1258 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |		\
1259 	 BTRFS_FEATURE_INCOMPAT_RAID56 |		\
1260 	 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |		\
1261 	 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |	\
1262 	 BTRFS_FEATURE_INCOMPAT_NO_HOLES	|	\
1263 	 BTRFS_FEATURE_INCOMPAT_METADATA_UUID	|	\
1264 	 BTRFS_FEATURE_INCOMPAT_RAID1C34)
1265 
1266 #define BTRFS_FEATURE_INCOMPAT_SAFE_SET			\
1267 	(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
1268 #define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR		0ULL
1269 
1270 #define BTRFS_BACKREF_REV_MAX		256
1271 #define BTRFS_BACKREF_REV_SHIFT		56
1272 #define BTRFS_BACKREF_REV_MASK		(((u64)BTRFS_BACKREF_REV_MAX - 1) << \
1273 					 BTRFS_BACKREF_REV_SHIFT)
1274 
1275 #define BTRFS_OLD_BACKREF_REV		0
1276 #define BTRFS_MIXED_BACKREF_REV		1
1277 
1278 #define BTRFS_MAX_LEVEL 8
1279 
1280 /* Every tree block (leaf or node) starts with this header. */
1281 struct btrfs_header {
1282 	/* These first four must match the super block */
1283 	u8 csum[BTRFS_CSUM_SIZE];
1284 	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
1285 	__le64 bytenr; /* Which block this node is supposed to live in */
1286 	__le64 flags;
1287 
1288 	/* Allowed to be different from the super from here on down. */
1289 	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
1290 	__le64 generation;
1291 	__le64 owner;
1292 	__le32 nritems;
1293 	u8 level;
1294 } __attribute__ ((__packed__));
1295 
1296 /*
1297  * A leaf is full of items. Offset and size tell us where to find
1298  * the item in the leaf (relative to the start of the data area).
1299  */
1300 struct btrfs_item {
1301 	struct btrfs_disk_key key;
1302 	__le32 offset;
1303 	__le32 size;
1304 } __attribute__ ((__packed__));
1305 
1306 /*
1307  * leaves have an item area and a data area:
1308  * [item0, item1....itemN] [free space] [dataN...data1, data0]
1309  *
1310  * The data is separate from the items to get the keys closer together
1311  * during searches.
1312  */
1313 struct btrfs_leaf {
1314 	struct btrfs_header header;
1315 	struct btrfs_item items[];
1316 } __attribute__ ((__packed__));
1317 
1318 /*
1319  * All non-leaf blocks are nodes, they hold only keys and pointers to children
1320  * blocks.
1321  */
1322 struct btrfs_key_ptr {
1323 	struct btrfs_disk_key key;
1324 	__le64 blockptr;
1325 	__le64 generation;
1326 } __attribute__ ((__packed__));
1327 
1328 struct btrfs_node {
1329 	struct btrfs_header header;
1330 	struct btrfs_key_ptr ptrs[];
1331 } __attribute__ ((__packed__));
1332 
1333 #endif /* __BTRFS_TREE_H__ */
1334