1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 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/semaphore.h> 27 #include <linux/completion.h> 28 #include <linux/backing-dev.h> 29 #include <linux/wait.h> 30 #include <linux/slab.h> 31 #include <linux/kobject.h> 32 #include <trace/events/btrfs.h> 33 #include <asm/kmap_types.h> 34 #include <linux/pagemap.h> 35 #include <linux/btrfs.h> 36 #include <linux/workqueue.h> 37 #include <linux/security.h> 38 #include "extent_io.h" 39 #include "extent_map.h" 40 #include "async-thread.h" 41 42 struct btrfs_trans_handle; 43 struct btrfs_transaction; 44 struct btrfs_pending_snapshot; 45 extern struct kmem_cache *btrfs_trans_handle_cachep; 46 extern struct kmem_cache *btrfs_transaction_cachep; 47 extern struct kmem_cache *btrfs_bit_radix_cachep; 48 extern struct kmem_cache *btrfs_path_cachep; 49 extern struct kmem_cache *btrfs_free_space_cachep; 50 struct btrfs_ordered_sum; 51 52 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 53 #define STATIC noinline 54 #else 55 #define STATIC static noinline 56 #endif 57 58 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */ 59 60 #define BTRFS_MAX_MIRRORS 3 61 62 #define BTRFS_MAX_LEVEL 8 63 64 #define BTRFS_COMPAT_EXTENT_TREE_V0 65 66 /* holds pointers to all of the tree roots */ 67 #define BTRFS_ROOT_TREE_OBJECTID 1ULL 68 69 /* stores information about which extents are in use, and reference counts */ 70 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL 71 72 /* 73 * chunk tree stores translations from logical -> physical block numbering 74 * the super block points to the chunk tree 75 */ 76 #define BTRFS_CHUNK_TREE_OBJECTID 3ULL 77 78 /* 79 * stores information about which areas of a given device are in use. 80 * one per device. The tree of tree roots points to the device tree 81 */ 82 #define BTRFS_DEV_TREE_OBJECTID 4ULL 83 84 /* one per subvolume, storing files and directories */ 85 #define BTRFS_FS_TREE_OBJECTID 5ULL 86 87 /* directory objectid inside the root tree */ 88 #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL 89 90 /* holds checksums of all the data extents */ 91 #define BTRFS_CSUM_TREE_OBJECTID 7ULL 92 93 /* holds quota configuration and tracking */ 94 #define BTRFS_QUOTA_TREE_OBJECTID 8ULL 95 96 /* for storing items that use the BTRFS_UUID_KEY* types */ 97 #define BTRFS_UUID_TREE_OBJECTID 9ULL 98 99 /* for storing balance parameters in the root tree */ 100 #define BTRFS_BALANCE_OBJECTID -4ULL 101 102 /* orhpan objectid for tracking unlinked/truncated files */ 103 #define BTRFS_ORPHAN_OBJECTID -5ULL 104 105 /* does write ahead logging to speed up fsyncs */ 106 #define BTRFS_TREE_LOG_OBJECTID -6ULL 107 #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL 108 109 /* for space balancing */ 110 #define BTRFS_TREE_RELOC_OBJECTID -8ULL 111 #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL 112 113 /* 114 * extent checksums all have this objectid 115 * this allows them to share the logging tree 116 * for fsyncs 117 */ 118 #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL 119 120 /* For storing free space cache */ 121 #define BTRFS_FREE_SPACE_OBJECTID -11ULL 122 123 /* 124 * The inode number assigned to the special inode for storing 125 * free ino cache 126 */ 127 #define BTRFS_FREE_INO_OBJECTID -12ULL 128 129 /* dummy objectid represents multiple objectids */ 130 #define BTRFS_MULTIPLE_OBJECTIDS -255ULL 131 132 /* 133 * All files have objectids in this range. 134 */ 135 #define BTRFS_FIRST_FREE_OBJECTID 256ULL 136 #define BTRFS_LAST_FREE_OBJECTID -256ULL 137 #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL 138 139 140 /* 141 * the device items go into the chunk tree. The key is in the form 142 * [ 1 BTRFS_DEV_ITEM_KEY device_id ] 143 */ 144 #define BTRFS_DEV_ITEMS_OBJECTID 1ULL 145 146 #define BTRFS_BTREE_INODE_OBJECTID 1 147 148 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2 149 150 #define BTRFS_DEV_REPLACE_DEVID 0ULL 151 152 /* 153 * the max metadata block size. This limit is somewhat artificial, 154 * but the memmove costs go through the roof for larger blocks. 155 */ 156 #define BTRFS_MAX_METADATA_BLOCKSIZE 65536 157 158 /* 159 * we can actually store much bigger names, but lets not confuse the rest 160 * of linux 161 */ 162 #define BTRFS_NAME_LEN 255 163 164 /* 165 * Theoretical limit is larger, but we keep this down to a sane 166 * value. That should limit greatly the possibility of collisions on 167 * inode ref items. 168 */ 169 #define BTRFS_LINK_MAX 65535U 170 171 /* 32 bytes in various csum fields */ 172 #define BTRFS_CSUM_SIZE 32 173 174 /* csum types */ 175 #define BTRFS_CSUM_TYPE_CRC32 0 176 177 static int btrfs_csum_sizes[] = { 4 }; 178 179 /* four bytes for CRC32 */ 180 #define BTRFS_EMPTY_DIR_SIZE 0 181 182 /* spefic to btrfs_map_block(), therefore not in include/linux/blk_types.h */ 183 #define REQ_GET_READ_MIRRORS (1 << 30) 184 185 #define BTRFS_FT_UNKNOWN 0 186 #define BTRFS_FT_REG_FILE 1 187 #define BTRFS_FT_DIR 2 188 #define BTRFS_FT_CHRDEV 3 189 #define BTRFS_FT_BLKDEV 4 190 #define BTRFS_FT_FIFO 5 191 #define BTRFS_FT_SOCK 6 192 #define BTRFS_FT_SYMLINK 7 193 #define BTRFS_FT_XATTR 8 194 #define BTRFS_FT_MAX 9 195 196 /* ioprio of readahead is set to idle */ 197 #define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0)) 198 199 #define BTRFS_DIRTY_METADATA_THRESH (32 * 1024 * 1024) 200 201 #define BTRFS_MAX_EXTENT_SIZE (128 * 1024 * 1024) 202 203 /* 204 * The key defines the order in the tree, and so it also defines (optimal) 205 * block layout. 206 * 207 * objectid corresponds to the inode number. 208 * 209 * type tells us things about the object, and is a kind of stream selector. 210 * so for a given inode, keys with type of 1 might refer to the inode data, 211 * type of 2 may point to file data in the btree and type == 3 may point to 212 * extents. 213 * 214 * offset is the starting byte offset for this key in the stream. 215 * 216 * btrfs_disk_key is in disk byte order. struct btrfs_key is always 217 * in cpu native order. Otherwise they are identical and their sizes 218 * should be the same (ie both packed) 219 */ 220 struct btrfs_disk_key { 221 __le64 objectid; 222 u8 type; 223 __le64 offset; 224 } __attribute__ ((__packed__)); 225 226 struct btrfs_key { 227 u64 objectid; 228 u8 type; 229 u64 offset; 230 } __attribute__ ((__packed__)); 231 232 struct btrfs_mapping_tree { 233 struct extent_map_tree map_tree; 234 }; 235 236 struct btrfs_dev_item { 237 /* the internal btrfs device id */ 238 __le64 devid; 239 240 /* size of the device */ 241 __le64 total_bytes; 242 243 /* bytes used */ 244 __le64 bytes_used; 245 246 /* optimal io alignment for this device */ 247 __le32 io_align; 248 249 /* optimal io width for this device */ 250 __le32 io_width; 251 252 /* minimal io size for this device */ 253 __le32 sector_size; 254 255 /* type and info about this device */ 256 __le64 type; 257 258 /* expected generation for this device */ 259 __le64 generation; 260 261 /* 262 * starting byte of this partition on the device, 263 * to allow for stripe alignment in the future 264 */ 265 __le64 start_offset; 266 267 /* grouping information for allocation decisions */ 268 __le32 dev_group; 269 270 /* seek speed 0-100 where 100 is fastest */ 271 u8 seek_speed; 272 273 /* bandwidth 0-100 where 100 is fastest */ 274 u8 bandwidth; 275 276 /* btrfs generated uuid for this device */ 277 u8 uuid[BTRFS_UUID_SIZE]; 278 279 /* uuid of FS who owns this device */ 280 u8 fsid[BTRFS_UUID_SIZE]; 281 } __attribute__ ((__packed__)); 282 283 struct btrfs_stripe { 284 __le64 devid; 285 __le64 offset; 286 u8 dev_uuid[BTRFS_UUID_SIZE]; 287 } __attribute__ ((__packed__)); 288 289 struct btrfs_chunk { 290 /* size of this chunk in bytes */ 291 __le64 length; 292 293 /* objectid of the root referencing this chunk */ 294 __le64 owner; 295 296 __le64 stripe_len; 297 __le64 type; 298 299 /* optimal io alignment for this chunk */ 300 __le32 io_align; 301 302 /* optimal io width for this chunk */ 303 __le32 io_width; 304 305 /* minimal io size for this chunk */ 306 __le32 sector_size; 307 308 /* 2^16 stripes is quite a lot, a second limit is the size of a single 309 * item in the btree 310 */ 311 __le16 num_stripes; 312 313 /* sub stripes only matter for raid10 */ 314 __le16 sub_stripes; 315 struct btrfs_stripe stripe; 316 /* additional stripes go here */ 317 } __attribute__ ((__packed__)); 318 319 #define BTRFS_FREE_SPACE_EXTENT 1 320 #define BTRFS_FREE_SPACE_BITMAP 2 321 322 struct btrfs_free_space_entry { 323 __le64 offset; 324 __le64 bytes; 325 u8 type; 326 } __attribute__ ((__packed__)); 327 328 struct btrfs_free_space_header { 329 struct btrfs_disk_key location; 330 __le64 generation; 331 __le64 num_entries; 332 __le64 num_bitmaps; 333 } __attribute__ ((__packed__)); 334 335 static inline unsigned long btrfs_chunk_item_size(int num_stripes) 336 { 337 BUG_ON(num_stripes == 0); 338 return sizeof(struct btrfs_chunk) + 339 sizeof(struct btrfs_stripe) * (num_stripes - 1); 340 } 341 342 #define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0) 343 #define BTRFS_HEADER_FLAG_RELOC (1ULL << 1) 344 345 /* 346 * File system states 347 */ 348 #define BTRFS_FS_STATE_ERROR 0 349 #define BTRFS_FS_STATE_REMOUNTING 1 350 #define BTRFS_FS_STATE_TRANS_ABORTED 2 351 #define BTRFS_FS_STATE_DEV_REPLACING 3 352 353 /* Super block flags */ 354 /* Errors detected */ 355 #define BTRFS_SUPER_FLAG_ERROR (1ULL << 2) 356 357 #define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32) 358 #define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33) 359 360 #define BTRFS_BACKREF_REV_MAX 256 361 #define BTRFS_BACKREF_REV_SHIFT 56 362 #define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \ 363 BTRFS_BACKREF_REV_SHIFT) 364 365 #define BTRFS_OLD_BACKREF_REV 0 366 #define BTRFS_MIXED_BACKREF_REV 1 367 368 /* 369 * every tree block (leaf or node) starts with this header. 370 */ 371 struct btrfs_header { 372 /* these first four must match the super block */ 373 u8 csum[BTRFS_CSUM_SIZE]; 374 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 375 __le64 bytenr; /* which block this node is supposed to live in */ 376 __le64 flags; 377 378 /* allowed to be different from the super from here on down */ 379 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 380 __le64 generation; 381 __le64 owner; 382 __le32 nritems; 383 u8 level; 384 } __attribute__ ((__packed__)); 385 386 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \ 387 sizeof(struct btrfs_header)) / \ 388 sizeof(struct btrfs_key_ptr)) 389 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header)) 390 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->nodesize)) 391 #define BTRFS_FILE_EXTENT_INLINE_DATA_START \ 392 (offsetof(struct btrfs_file_extent_item, disk_bytenr)) 393 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ 394 sizeof(struct btrfs_item) - \ 395 BTRFS_FILE_EXTENT_INLINE_DATA_START) 396 #define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ 397 sizeof(struct btrfs_item) -\ 398 sizeof(struct btrfs_dir_item)) 399 400 401 /* 402 * this is a very generous portion of the super block, giving us 403 * room to translate 14 chunks with 3 stripes each. 404 */ 405 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048 406 #define BTRFS_LABEL_SIZE 256 407 408 /* 409 * just in case we somehow lose the roots and are not able to mount, 410 * we store an array of the roots from previous transactions 411 * in the super. 412 */ 413 #define BTRFS_NUM_BACKUP_ROOTS 4 414 struct btrfs_root_backup { 415 __le64 tree_root; 416 __le64 tree_root_gen; 417 418 __le64 chunk_root; 419 __le64 chunk_root_gen; 420 421 __le64 extent_root; 422 __le64 extent_root_gen; 423 424 __le64 fs_root; 425 __le64 fs_root_gen; 426 427 __le64 dev_root; 428 __le64 dev_root_gen; 429 430 __le64 csum_root; 431 __le64 csum_root_gen; 432 433 __le64 total_bytes; 434 __le64 bytes_used; 435 __le64 num_devices; 436 /* future */ 437 __le64 unused_64[4]; 438 439 u8 tree_root_level; 440 u8 chunk_root_level; 441 u8 extent_root_level; 442 u8 fs_root_level; 443 u8 dev_root_level; 444 u8 csum_root_level; 445 /* future and to align */ 446 u8 unused_8[10]; 447 } __attribute__ ((__packed__)); 448 449 /* 450 * the super block basically lists the main trees of the FS 451 * it currently lacks any block count etc etc 452 */ 453 struct btrfs_super_block { 454 u8 csum[BTRFS_CSUM_SIZE]; 455 /* the first 4 fields must match struct btrfs_header */ 456 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 457 __le64 bytenr; /* this block number */ 458 __le64 flags; 459 460 /* allowed to be different from the btrfs_header from here own down */ 461 __le64 magic; 462 __le64 generation; 463 __le64 root; 464 __le64 chunk_root; 465 __le64 log_root; 466 467 /* this will help find the new super based on the log root */ 468 __le64 log_root_transid; 469 __le64 total_bytes; 470 __le64 bytes_used; 471 __le64 root_dir_objectid; 472 __le64 num_devices; 473 __le32 sectorsize; 474 __le32 nodesize; 475 __le32 __unused_leafsize; 476 __le32 stripesize; 477 __le32 sys_chunk_array_size; 478 __le64 chunk_root_generation; 479 __le64 compat_flags; 480 __le64 compat_ro_flags; 481 __le64 incompat_flags; 482 __le16 csum_type; 483 u8 root_level; 484 u8 chunk_root_level; 485 u8 log_root_level; 486 struct btrfs_dev_item dev_item; 487 488 char label[BTRFS_LABEL_SIZE]; 489 490 __le64 cache_generation; 491 __le64 uuid_tree_generation; 492 493 /* future expansion */ 494 __le64 reserved[30]; 495 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; 496 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS]; 497 } __attribute__ ((__packed__)); 498 499 /* 500 * Compat flags that we support. If any incompat flags are set other than the 501 * ones specified below then we will fail to mount 502 */ 503 #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0) 504 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1) 505 #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2) 506 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3) 507 /* 508 * some patches floated around with a second compression method 509 * lets save that incompat here for when they do get in 510 * Note we don't actually support it, we're just reserving the 511 * number 512 */ 513 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2 (1ULL << 4) 514 515 /* 516 * older kernels tried to do bigger metadata blocks, but the 517 * code was pretty buggy. Lets not let them try anymore. 518 */ 519 #define BTRFS_FEATURE_INCOMPAT_BIG_METADATA (1ULL << 5) 520 521 #define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF (1ULL << 6) 522 #define BTRFS_FEATURE_INCOMPAT_RAID56 (1ULL << 7) 523 #define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA (1ULL << 8) 524 #define BTRFS_FEATURE_INCOMPAT_NO_HOLES (1ULL << 9) 525 526 #define BTRFS_FEATURE_COMPAT_SUPP 0ULL 527 #define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL 528 #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL 529 #define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL 530 #define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL 531 #define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL 532 533 #define BTRFS_FEATURE_INCOMPAT_SUPP \ 534 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \ 535 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \ 536 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \ 537 BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \ 538 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \ 539 BTRFS_FEATURE_INCOMPAT_RAID56 | \ 540 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \ 541 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \ 542 BTRFS_FEATURE_INCOMPAT_NO_HOLES) 543 544 #define BTRFS_FEATURE_INCOMPAT_SAFE_SET \ 545 (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF) 546 #define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL 547 548 /* 549 * A leaf is full of items. offset and size tell us where to find 550 * the item in the leaf (relative to the start of the data area) 551 */ 552 struct btrfs_item { 553 struct btrfs_disk_key key; 554 __le32 offset; 555 __le32 size; 556 } __attribute__ ((__packed__)); 557 558 /* 559 * leaves have an item area and a data area: 560 * [item0, item1....itemN] [free space] [dataN...data1, data0] 561 * 562 * The data is separate from the items to get the keys closer together 563 * during searches. 564 */ 565 struct btrfs_leaf { 566 struct btrfs_header header; 567 struct btrfs_item items[]; 568 } __attribute__ ((__packed__)); 569 570 /* 571 * all non-leaf blocks are nodes, they hold only keys and pointers to 572 * other blocks 573 */ 574 struct btrfs_key_ptr { 575 struct btrfs_disk_key key; 576 __le64 blockptr; 577 __le64 generation; 578 } __attribute__ ((__packed__)); 579 580 struct btrfs_node { 581 struct btrfs_header header; 582 struct btrfs_key_ptr ptrs[]; 583 } __attribute__ ((__packed__)); 584 585 /* 586 * btrfs_paths remember the path taken from the root down to the leaf. 587 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point 588 * to any other levels that are present. 589 * 590 * The slots array records the index of the item or block pointer 591 * used while walking the tree. 592 */ 593 struct btrfs_path { 594 struct extent_buffer *nodes[BTRFS_MAX_LEVEL]; 595 int slots[BTRFS_MAX_LEVEL]; 596 /* if there is real range locking, this locks field will change */ 597 int locks[BTRFS_MAX_LEVEL]; 598 int reada; 599 /* keep some upper locks as we walk down */ 600 int lowest_level; 601 602 /* 603 * set by btrfs_split_item, tells search_slot to keep all locks 604 * and to force calls to keep space in the nodes 605 */ 606 unsigned int search_for_split:1; 607 unsigned int keep_locks:1; 608 unsigned int skip_locking:1; 609 unsigned int leave_spinning:1; 610 unsigned int search_commit_root:1; 611 unsigned int need_commit_sem:1; 612 unsigned int skip_release_on_error:1; 613 }; 614 615 /* 616 * items in the extent btree are used to record the objectid of the 617 * owner of the block and the number of references 618 */ 619 620 struct btrfs_extent_item { 621 __le64 refs; 622 __le64 generation; 623 __le64 flags; 624 } __attribute__ ((__packed__)); 625 626 struct btrfs_extent_item_v0 { 627 __le32 refs; 628 } __attribute__ ((__packed__)); 629 630 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \ 631 sizeof(struct btrfs_item)) 632 633 #define BTRFS_EXTENT_FLAG_DATA (1ULL << 0) 634 #define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1) 635 636 /* following flags only apply to tree blocks */ 637 638 /* use full backrefs for extent pointers in the block */ 639 #define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8) 640 641 /* 642 * this flag is only used internally by scrub and may be changed at any time 643 * it is only declared here to avoid collisions 644 */ 645 #define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48) 646 647 struct btrfs_tree_block_info { 648 struct btrfs_disk_key key; 649 u8 level; 650 } __attribute__ ((__packed__)); 651 652 struct btrfs_extent_data_ref { 653 __le64 root; 654 __le64 objectid; 655 __le64 offset; 656 __le32 count; 657 } __attribute__ ((__packed__)); 658 659 struct btrfs_shared_data_ref { 660 __le32 count; 661 } __attribute__ ((__packed__)); 662 663 struct btrfs_extent_inline_ref { 664 u8 type; 665 __le64 offset; 666 } __attribute__ ((__packed__)); 667 668 /* old style backrefs item */ 669 struct btrfs_extent_ref_v0 { 670 __le64 root; 671 __le64 generation; 672 __le64 objectid; 673 __le32 count; 674 } __attribute__ ((__packed__)); 675 676 677 /* dev extents record free space on individual devices. The owner 678 * field points back to the chunk allocation mapping tree that allocated 679 * the extent. The chunk tree uuid field is a way to double check the owner 680 */ 681 struct btrfs_dev_extent { 682 __le64 chunk_tree; 683 __le64 chunk_objectid; 684 __le64 chunk_offset; 685 __le64 length; 686 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 687 } __attribute__ ((__packed__)); 688 689 struct btrfs_inode_ref { 690 __le64 index; 691 __le16 name_len; 692 /* name goes here */ 693 } __attribute__ ((__packed__)); 694 695 struct btrfs_inode_extref { 696 __le64 parent_objectid; 697 __le64 index; 698 __le16 name_len; 699 __u8 name[0]; 700 /* name goes here */ 701 } __attribute__ ((__packed__)); 702 703 struct btrfs_timespec { 704 __le64 sec; 705 __le32 nsec; 706 } __attribute__ ((__packed__)); 707 708 enum btrfs_compression_type { 709 BTRFS_COMPRESS_NONE = 0, 710 BTRFS_COMPRESS_ZLIB = 1, 711 BTRFS_COMPRESS_LZO = 2, 712 BTRFS_COMPRESS_TYPES = 2, 713 BTRFS_COMPRESS_LAST = 3, 714 }; 715 716 struct btrfs_inode_item { 717 /* nfs style generation number */ 718 __le64 generation; 719 /* transid that last touched this inode */ 720 __le64 transid; 721 __le64 size; 722 __le64 nbytes; 723 __le64 block_group; 724 __le32 nlink; 725 __le32 uid; 726 __le32 gid; 727 __le32 mode; 728 __le64 rdev; 729 __le64 flags; 730 731 /* modification sequence number for NFS */ 732 __le64 sequence; 733 734 /* 735 * a little future expansion, for more than this we can 736 * just grow the inode item and version it 737 */ 738 __le64 reserved[4]; 739 struct btrfs_timespec atime; 740 struct btrfs_timespec ctime; 741 struct btrfs_timespec mtime; 742 struct btrfs_timespec otime; 743 } __attribute__ ((__packed__)); 744 745 struct btrfs_dir_log_item { 746 __le64 end; 747 } __attribute__ ((__packed__)); 748 749 struct btrfs_dir_item { 750 struct btrfs_disk_key location; 751 __le64 transid; 752 __le16 data_len; 753 __le16 name_len; 754 u8 type; 755 } __attribute__ ((__packed__)); 756 757 #define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0) 758 759 /* 760 * Internal in-memory flag that a subvolume has been marked for deletion but 761 * still visible as a directory 762 */ 763 #define BTRFS_ROOT_SUBVOL_DEAD (1ULL << 48) 764 765 struct btrfs_root_item { 766 struct btrfs_inode_item inode; 767 __le64 generation; 768 __le64 root_dirid; 769 __le64 bytenr; 770 __le64 byte_limit; 771 __le64 bytes_used; 772 __le64 last_snapshot; 773 __le64 flags; 774 __le32 refs; 775 struct btrfs_disk_key drop_progress; 776 u8 drop_level; 777 u8 level; 778 779 /* 780 * The following fields appear after subvol_uuids+subvol_times 781 * were introduced. 782 */ 783 784 /* 785 * This generation number is used to test if the new fields are valid 786 * and up to date while reading the root item. Everytime the root item 787 * is written out, the "generation" field is copied into this field. If 788 * anyone ever mounted the fs with an older kernel, we will have 789 * mismatching generation values here and thus must invalidate the 790 * new fields. See btrfs_update_root and btrfs_find_last_root for 791 * details. 792 * the offset of generation_v2 is also used as the start for the memset 793 * when invalidating the fields. 794 */ 795 __le64 generation_v2; 796 u8 uuid[BTRFS_UUID_SIZE]; 797 u8 parent_uuid[BTRFS_UUID_SIZE]; 798 u8 received_uuid[BTRFS_UUID_SIZE]; 799 __le64 ctransid; /* updated when an inode changes */ 800 __le64 otransid; /* trans when created */ 801 __le64 stransid; /* trans when sent. non-zero for received subvol */ 802 __le64 rtransid; /* trans when received. non-zero for received subvol */ 803 struct btrfs_timespec ctime; 804 struct btrfs_timespec otime; 805 struct btrfs_timespec stime; 806 struct btrfs_timespec rtime; 807 __le64 reserved[8]; /* for future */ 808 } __attribute__ ((__packed__)); 809 810 /* 811 * this is used for both forward and backward root refs 812 */ 813 struct btrfs_root_ref { 814 __le64 dirid; 815 __le64 sequence; 816 __le16 name_len; 817 } __attribute__ ((__packed__)); 818 819 struct btrfs_disk_balance_args { 820 /* 821 * profiles to operate on, single is denoted by 822 * BTRFS_AVAIL_ALLOC_BIT_SINGLE 823 */ 824 __le64 profiles; 825 826 /* usage filter */ 827 __le64 usage; 828 829 /* devid filter */ 830 __le64 devid; 831 832 /* devid subset filter [pstart..pend) */ 833 __le64 pstart; 834 __le64 pend; 835 836 /* btrfs virtual address space subset filter [vstart..vend) */ 837 __le64 vstart; 838 __le64 vend; 839 840 /* 841 * profile to convert to, single is denoted by 842 * BTRFS_AVAIL_ALLOC_BIT_SINGLE 843 */ 844 __le64 target; 845 846 /* BTRFS_BALANCE_ARGS_* */ 847 __le64 flags; 848 849 /* BTRFS_BALANCE_ARGS_LIMIT value */ 850 __le64 limit; 851 852 __le64 unused[7]; 853 } __attribute__ ((__packed__)); 854 855 /* 856 * store balance parameters to disk so that balance can be properly 857 * resumed after crash or unmount 858 */ 859 struct btrfs_balance_item { 860 /* BTRFS_BALANCE_* */ 861 __le64 flags; 862 863 struct btrfs_disk_balance_args data; 864 struct btrfs_disk_balance_args meta; 865 struct btrfs_disk_balance_args sys; 866 867 __le64 unused[4]; 868 } __attribute__ ((__packed__)); 869 870 #define BTRFS_FILE_EXTENT_INLINE 0 871 #define BTRFS_FILE_EXTENT_REG 1 872 #define BTRFS_FILE_EXTENT_PREALLOC 2 873 874 struct btrfs_file_extent_item { 875 /* 876 * transaction id that created this extent 877 */ 878 __le64 generation; 879 /* 880 * max number of bytes to hold this extent in ram 881 * when we split a compressed extent we can't know how big 882 * each of the resulting pieces will be. So, this is 883 * an upper limit on the size of the extent in ram instead of 884 * an exact limit. 885 */ 886 __le64 ram_bytes; 887 888 /* 889 * 32 bits for the various ways we might encode the data, 890 * including compression and encryption. If any of these 891 * are set to something a given disk format doesn't understand 892 * it is treated like an incompat flag for reading and writing, 893 * but not for stat. 894 */ 895 u8 compression; 896 u8 encryption; 897 __le16 other_encoding; /* spare for later use */ 898 899 /* are we inline data or a real extent? */ 900 u8 type; 901 902 /* 903 * disk space consumed by the extent, checksum blocks are included 904 * in these numbers 905 * 906 * At this offset in the structure, the inline extent data start. 907 */ 908 __le64 disk_bytenr; 909 __le64 disk_num_bytes; 910 /* 911 * the logical offset in file blocks (no csums) 912 * this extent record is for. This allows a file extent to point 913 * into the middle of an existing extent on disk, sharing it 914 * between two snapshots (useful if some bytes in the middle of the 915 * extent have changed 916 */ 917 __le64 offset; 918 /* 919 * the logical number of file blocks (no csums included). This 920 * always reflects the size uncompressed and without encoding. 921 */ 922 __le64 num_bytes; 923 924 } __attribute__ ((__packed__)); 925 926 struct btrfs_csum_item { 927 u8 csum; 928 } __attribute__ ((__packed__)); 929 930 struct btrfs_dev_stats_item { 931 /* 932 * grow this item struct at the end for future enhancements and keep 933 * the existing values unchanged 934 */ 935 __le64 values[BTRFS_DEV_STAT_VALUES_MAX]; 936 } __attribute__ ((__packed__)); 937 938 #define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 0 939 #define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID 1 940 #define BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED 0 941 #define BTRFS_DEV_REPLACE_ITEM_STATE_STARTED 1 942 #define BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED 2 943 #define BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED 3 944 #define BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED 4 945 946 struct btrfs_dev_replace { 947 u64 replace_state; /* see #define above */ 948 u64 time_started; /* seconds since 1-Jan-1970 */ 949 u64 time_stopped; /* seconds since 1-Jan-1970 */ 950 atomic64_t num_write_errors; 951 atomic64_t num_uncorrectable_read_errors; 952 953 u64 cursor_left; 954 u64 committed_cursor_left; 955 u64 cursor_left_last_write_of_item; 956 u64 cursor_right; 957 958 u64 cont_reading_from_srcdev_mode; /* see #define above */ 959 960 int is_valid; 961 int item_needs_writeback; 962 struct btrfs_device *srcdev; 963 struct btrfs_device *tgtdev; 964 965 pid_t lock_owner; 966 atomic_t nesting_level; 967 struct mutex lock_finishing_cancel_unmount; 968 struct mutex lock_management_lock; 969 struct mutex lock; 970 971 struct btrfs_scrub_progress scrub_progress; 972 }; 973 974 struct btrfs_dev_replace_item { 975 /* 976 * grow this item struct at the end for future enhancements and keep 977 * the existing values unchanged 978 */ 979 __le64 src_devid; 980 __le64 cursor_left; 981 __le64 cursor_right; 982 __le64 cont_reading_from_srcdev_mode; 983 984 __le64 replace_state; 985 __le64 time_started; 986 __le64 time_stopped; 987 __le64 num_write_errors; 988 __le64 num_uncorrectable_read_errors; 989 } __attribute__ ((__packed__)); 990 991 /* different types of block groups (and chunks) */ 992 #define BTRFS_BLOCK_GROUP_DATA (1ULL << 0) 993 #define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1) 994 #define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2) 995 #define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3) 996 #define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4) 997 #define BTRFS_BLOCK_GROUP_DUP (1ULL << 5) 998 #define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6) 999 #define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7) 1000 #define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8) 1001 #define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \ 1002 BTRFS_SPACE_INFO_GLOBAL_RSV) 1003 1004 enum btrfs_raid_types { 1005 BTRFS_RAID_RAID10, 1006 BTRFS_RAID_RAID1, 1007 BTRFS_RAID_DUP, 1008 BTRFS_RAID_RAID0, 1009 BTRFS_RAID_SINGLE, 1010 BTRFS_RAID_RAID5, 1011 BTRFS_RAID_RAID6, 1012 BTRFS_NR_RAID_TYPES 1013 }; 1014 1015 #define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \ 1016 BTRFS_BLOCK_GROUP_SYSTEM | \ 1017 BTRFS_BLOCK_GROUP_METADATA) 1018 1019 #define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \ 1020 BTRFS_BLOCK_GROUP_RAID1 | \ 1021 BTRFS_BLOCK_GROUP_RAID5 | \ 1022 BTRFS_BLOCK_GROUP_RAID6 | \ 1023 BTRFS_BLOCK_GROUP_DUP | \ 1024 BTRFS_BLOCK_GROUP_RAID10) 1025 #define BTRFS_BLOCK_GROUP_RAID56_MASK (BTRFS_BLOCK_GROUP_RAID5 | \ 1026 BTRFS_BLOCK_GROUP_RAID6) 1027 1028 /* 1029 * We need a bit for restriper to be able to tell when chunks of type 1030 * SINGLE are available. This "extended" profile format is used in 1031 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields 1032 * (on-disk). The corresponding on-disk bit in chunk.type is reserved 1033 * to avoid remappings between two formats in future. 1034 */ 1035 #define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48) 1036 1037 /* 1038 * A fake block group type that is used to communicate global block reserve 1039 * size to userspace via the SPACE_INFO ioctl. 1040 */ 1041 #define BTRFS_SPACE_INFO_GLOBAL_RSV (1ULL << 49) 1042 1043 #define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK | \ 1044 BTRFS_AVAIL_ALLOC_BIT_SINGLE) 1045 1046 static inline u64 chunk_to_extended(u64 flags) 1047 { 1048 if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0) 1049 flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE; 1050 1051 return flags; 1052 } 1053 static inline u64 extended_to_chunk(u64 flags) 1054 { 1055 return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE; 1056 } 1057 1058 struct btrfs_block_group_item { 1059 __le64 used; 1060 __le64 chunk_objectid; 1061 __le64 flags; 1062 } __attribute__ ((__packed__)); 1063 1064 #define BTRFS_QGROUP_LEVEL_SHIFT 48 1065 static inline u64 btrfs_qgroup_level(u64 qgroupid) 1066 { 1067 return qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT; 1068 } 1069 1070 /* 1071 * is subvolume quota turned on? 1072 */ 1073 #define BTRFS_QGROUP_STATUS_FLAG_ON (1ULL << 0) 1074 /* 1075 * RESCAN is set during the initialization phase 1076 */ 1077 #define BTRFS_QGROUP_STATUS_FLAG_RESCAN (1ULL << 1) 1078 /* 1079 * Some qgroup entries are known to be out of date, 1080 * either because the configuration has changed in a way that 1081 * makes a rescan necessary, or because the fs has been mounted 1082 * with a non-qgroup-aware version. 1083 * Turning qouta off and on again makes it inconsistent, too. 1084 */ 1085 #define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT (1ULL << 2) 1086 1087 #define BTRFS_QGROUP_STATUS_VERSION 1 1088 1089 struct btrfs_qgroup_status_item { 1090 __le64 version; 1091 /* 1092 * the generation is updated during every commit. As older 1093 * versions of btrfs are not aware of qgroups, it will be 1094 * possible to detect inconsistencies by checking the 1095 * generation on mount time 1096 */ 1097 __le64 generation; 1098 1099 /* flag definitions see above */ 1100 __le64 flags; 1101 1102 /* 1103 * only used during scanning to record the progress 1104 * of the scan. It contains a logical address 1105 */ 1106 __le64 rescan; 1107 } __attribute__ ((__packed__)); 1108 1109 struct btrfs_qgroup_info_item { 1110 __le64 generation; 1111 __le64 rfer; 1112 __le64 rfer_cmpr; 1113 __le64 excl; 1114 __le64 excl_cmpr; 1115 } __attribute__ ((__packed__)); 1116 1117 /* flags definition for qgroup limits */ 1118 #define BTRFS_QGROUP_LIMIT_MAX_RFER (1ULL << 0) 1119 #define BTRFS_QGROUP_LIMIT_MAX_EXCL (1ULL << 1) 1120 #define BTRFS_QGROUP_LIMIT_RSV_RFER (1ULL << 2) 1121 #define BTRFS_QGROUP_LIMIT_RSV_EXCL (1ULL << 3) 1122 #define BTRFS_QGROUP_LIMIT_RFER_CMPR (1ULL << 4) 1123 #define BTRFS_QGROUP_LIMIT_EXCL_CMPR (1ULL << 5) 1124 1125 struct btrfs_qgroup_limit_item { 1126 /* 1127 * only updated when any of the other values change 1128 */ 1129 __le64 flags; 1130 __le64 max_rfer; 1131 __le64 max_excl; 1132 __le64 rsv_rfer; 1133 __le64 rsv_excl; 1134 } __attribute__ ((__packed__)); 1135 1136 /* For raid type sysfs entries */ 1137 struct raid_kobject { 1138 int raid_type; 1139 struct kobject kobj; 1140 }; 1141 1142 struct btrfs_space_info { 1143 spinlock_t lock; 1144 1145 u64 total_bytes; /* total bytes in the space, 1146 this doesn't take mirrors into account */ 1147 u64 bytes_used; /* total bytes used, 1148 this doesn't take mirrors into account */ 1149 u64 bytes_pinned; /* total bytes pinned, will be freed when the 1150 transaction finishes */ 1151 u64 bytes_reserved; /* total bytes the allocator has reserved for 1152 current allocations */ 1153 u64 bytes_may_use; /* number of bytes that may be used for 1154 delalloc/allocations */ 1155 u64 bytes_readonly; /* total bytes that are read only */ 1156 1157 unsigned int full:1; /* indicates that we cannot allocate any more 1158 chunks for this space */ 1159 unsigned int chunk_alloc:1; /* set if we are allocating a chunk */ 1160 1161 unsigned int flush:1; /* set if we are trying to make space */ 1162 1163 unsigned int force_alloc; /* set if we need to force a chunk 1164 alloc for this space */ 1165 1166 u64 disk_used; /* total bytes used on disk */ 1167 u64 disk_total; /* total bytes on disk, takes mirrors into 1168 account */ 1169 1170 u64 flags; 1171 1172 /* 1173 * bytes_pinned is kept in line with what is actually pinned, as in 1174 * we've called update_block_group and dropped the bytes_used counter 1175 * and increased the bytes_pinned counter. However this means that 1176 * bytes_pinned does not reflect the bytes that will be pinned once the 1177 * delayed refs are flushed, so this counter is inc'ed everytime we call 1178 * btrfs_free_extent so it is a realtime count of what will be freed 1179 * once the transaction is committed. It will be zero'ed everytime the 1180 * transaction commits. 1181 */ 1182 struct percpu_counter total_bytes_pinned; 1183 1184 struct list_head list; 1185 /* Protected by the spinlock 'lock'. */ 1186 struct list_head ro_bgs; 1187 1188 struct rw_semaphore groups_sem; 1189 /* for block groups in our same type */ 1190 struct list_head block_groups[BTRFS_NR_RAID_TYPES]; 1191 wait_queue_head_t wait; 1192 1193 struct kobject kobj; 1194 struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES]; 1195 }; 1196 1197 #define BTRFS_BLOCK_RSV_GLOBAL 1 1198 #define BTRFS_BLOCK_RSV_DELALLOC 2 1199 #define BTRFS_BLOCK_RSV_TRANS 3 1200 #define BTRFS_BLOCK_RSV_CHUNK 4 1201 #define BTRFS_BLOCK_RSV_DELOPS 5 1202 #define BTRFS_BLOCK_RSV_EMPTY 6 1203 #define BTRFS_BLOCK_RSV_TEMP 7 1204 1205 struct btrfs_block_rsv { 1206 u64 size; 1207 u64 reserved; 1208 struct btrfs_space_info *space_info; 1209 spinlock_t lock; 1210 unsigned short full; 1211 unsigned short type; 1212 unsigned short failfast; 1213 }; 1214 1215 /* 1216 * free clusters are used to claim free space in relatively large chunks, 1217 * allowing us to do less seeky writes. They are used for all metadata 1218 * allocations and data allocations in ssd mode. 1219 */ 1220 struct btrfs_free_cluster { 1221 spinlock_t lock; 1222 spinlock_t refill_lock; 1223 struct rb_root root; 1224 1225 /* largest extent in this cluster */ 1226 u64 max_size; 1227 1228 /* first extent starting offset */ 1229 u64 window_start; 1230 1231 struct btrfs_block_group_cache *block_group; 1232 /* 1233 * when a cluster is allocated from a block group, we put the 1234 * cluster onto a list in the block group so that it can 1235 * be freed before the block group is freed. 1236 */ 1237 struct list_head block_group_list; 1238 }; 1239 1240 enum btrfs_caching_type { 1241 BTRFS_CACHE_NO = 0, 1242 BTRFS_CACHE_STARTED = 1, 1243 BTRFS_CACHE_FAST = 2, 1244 BTRFS_CACHE_FINISHED = 3, 1245 BTRFS_CACHE_ERROR = 4, 1246 }; 1247 1248 enum btrfs_disk_cache_state { 1249 BTRFS_DC_WRITTEN = 0, 1250 BTRFS_DC_ERROR = 1, 1251 BTRFS_DC_CLEAR = 2, 1252 BTRFS_DC_SETUP = 3, 1253 }; 1254 1255 struct btrfs_caching_control { 1256 struct list_head list; 1257 struct mutex mutex; 1258 wait_queue_head_t wait; 1259 struct btrfs_work work; 1260 struct btrfs_block_group_cache *block_group; 1261 u64 progress; 1262 atomic_t count; 1263 }; 1264 1265 struct btrfs_io_ctl { 1266 void *cur, *orig; 1267 struct page *page; 1268 struct page **pages; 1269 struct btrfs_root *root; 1270 struct inode *inode; 1271 unsigned long size; 1272 int index; 1273 int num_pages; 1274 int entries; 1275 int bitmaps; 1276 unsigned check_crcs:1; 1277 }; 1278 1279 struct btrfs_block_group_cache { 1280 struct btrfs_key key; 1281 struct btrfs_block_group_item item; 1282 struct btrfs_fs_info *fs_info; 1283 struct inode *inode; 1284 spinlock_t lock; 1285 u64 pinned; 1286 u64 reserved; 1287 u64 delalloc_bytes; 1288 u64 bytes_super; 1289 u64 flags; 1290 u64 sectorsize; 1291 u64 cache_generation; 1292 1293 /* 1294 * It is just used for the delayed data space allocation because 1295 * only the data space allocation and the relative metadata update 1296 * can be done cross the transaction. 1297 */ 1298 struct rw_semaphore data_rwsem; 1299 1300 /* for raid56, this is a full stripe, without parity */ 1301 unsigned long full_stripe_len; 1302 1303 unsigned int ro:1; 1304 unsigned int iref:1; 1305 unsigned int has_caching_ctl:1; 1306 unsigned int removed:1; 1307 1308 int disk_cache_state; 1309 1310 /* cache tracking stuff */ 1311 int cached; 1312 struct btrfs_caching_control *caching_ctl; 1313 u64 last_byte_to_unpin; 1314 1315 struct btrfs_space_info *space_info; 1316 1317 /* free space cache stuff */ 1318 struct btrfs_free_space_ctl *free_space_ctl; 1319 1320 /* block group cache stuff */ 1321 struct rb_node cache_node; 1322 1323 /* for block groups in the same raid type */ 1324 struct list_head list; 1325 1326 /* usage count */ 1327 atomic_t count; 1328 1329 /* List of struct btrfs_free_clusters for this block group. 1330 * Today it will only have one thing on it, but that may change 1331 */ 1332 struct list_head cluster_list; 1333 1334 /* For delayed block group creation or deletion of empty block groups */ 1335 struct list_head bg_list; 1336 1337 /* For read-only block groups */ 1338 struct list_head ro_list; 1339 1340 atomic_t trimming; 1341 1342 /* For dirty block groups */ 1343 struct list_head dirty_list; 1344 struct list_head io_list; 1345 1346 struct btrfs_io_ctl io_ctl; 1347 }; 1348 1349 /* delayed seq elem */ 1350 struct seq_list { 1351 struct list_head list; 1352 u64 seq; 1353 }; 1354 1355 #define SEQ_LIST_INIT(name) { .list = LIST_HEAD_INIT((name).list), .seq = 0 } 1356 1357 enum btrfs_orphan_cleanup_state { 1358 ORPHAN_CLEANUP_STARTED = 1, 1359 ORPHAN_CLEANUP_DONE = 2, 1360 }; 1361 1362 /* used by the raid56 code to lock stripes for read/modify/write */ 1363 struct btrfs_stripe_hash { 1364 struct list_head hash_list; 1365 wait_queue_head_t wait; 1366 spinlock_t lock; 1367 }; 1368 1369 /* used by the raid56 code to lock stripes for read/modify/write */ 1370 struct btrfs_stripe_hash_table { 1371 struct list_head stripe_cache; 1372 spinlock_t cache_lock; 1373 int cache_size; 1374 struct btrfs_stripe_hash table[]; 1375 }; 1376 1377 #define BTRFS_STRIPE_HASH_TABLE_BITS 11 1378 1379 void btrfs_init_async_reclaim_work(struct work_struct *work); 1380 1381 /* fs_info */ 1382 struct reloc_control; 1383 struct btrfs_device; 1384 struct btrfs_fs_devices; 1385 struct btrfs_balance_control; 1386 struct btrfs_delayed_root; 1387 struct btrfs_fs_info { 1388 u8 fsid[BTRFS_FSID_SIZE]; 1389 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 1390 struct btrfs_root *extent_root; 1391 struct btrfs_root *tree_root; 1392 struct btrfs_root *chunk_root; 1393 struct btrfs_root *dev_root; 1394 struct btrfs_root *fs_root; 1395 struct btrfs_root *csum_root; 1396 struct btrfs_root *quota_root; 1397 struct btrfs_root *uuid_root; 1398 1399 /* the log root tree is a directory of all the other log roots */ 1400 struct btrfs_root *log_root_tree; 1401 1402 spinlock_t fs_roots_radix_lock; 1403 struct radix_tree_root fs_roots_radix; 1404 1405 /* block group cache stuff */ 1406 spinlock_t block_group_cache_lock; 1407 u64 first_logical_byte; 1408 struct rb_root block_group_cache_tree; 1409 1410 /* keep track of unallocated space */ 1411 spinlock_t free_chunk_lock; 1412 u64 free_chunk_space; 1413 1414 struct extent_io_tree freed_extents[2]; 1415 struct extent_io_tree *pinned_extents; 1416 1417 /* logical->physical extent mapping */ 1418 struct btrfs_mapping_tree mapping_tree; 1419 1420 /* 1421 * block reservation for extent, checksum, root tree and 1422 * delayed dir index item 1423 */ 1424 struct btrfs_block_rsv global_block_rsv; 1425 /* block reservation for delay allocation */ 1426 struct btrfs_block_rsv delalloc_block_rsv; 1427 /* block reservation for metadata operations */ 1428 struct btrfs_block_rsv trans_block_rsv; 1429 /* block reservation for chunk tree */ 1430 struct btrfs_block_rsv chunk_block_rsv; 1431 /* block reservation for delayed operations */ 1432 struct btrfs_block_rsv delayed_block_rsv; 1433 1434 struct btrfs_block_rsv empty_block_rsv; 1435 1436 u64 generation; 1437 u64 last_trans_committed; 1438 u64 avg_delayed_ref_runtime; 1439 1440 /* 1441 * this is updated to the current trans every time a full commit 1442 * is required instead of the faster short fsync log commits 1443 */ 1444 u64 last_trans_log_full_commit; 1445 unsigned long mount_opt; 1446 /* 1447 * Track requests for actions that need to be done during transaction 1448 * commit (like for some mount options). 1449 */ 1450 unsigned long pending_changes; 1451 unsigned long compress_type:4; 1452 int commit_interval; 1453 /* 1454 * It is a suggestive number, the read side is safe even it gets a 1455 * wrong number because we will write out the data into a regular 1456 * extent. The write side(mount/remount) is under ->s_umount lock, 1457 * so it is also safe. 1458 */ 1459 u64 max_inline; 1460 /* 1461 * Protected by ->chunk_mutex and sb->s_umount. 1462 * 1463 * The reason that we use two lock to protect it is because only 1464 * remount and mount operations can change it and these two operations 1465 * are under sb->s_umount, but the read side (chunk allocation) can not 1466 * acquire sb->s_umount or the deadlock would happen. So we use two 1467 * locks to protect it. On the write side, we must acquire two locks, 1468 * and on the read side, we just need acquire one of them. 1469 */ 1470 u64 alloc_start; 1471 struct btrfs_transaction *running_transaction; 1472 wait_queue_head_t transaction_throttle; 1473 wait_queue_head_t transaction_wait; 1474 wait_queue_head_t transaction_blocked_wait; 1475 wait_queue_head_t async_submit_wait; 1476 1477 /* 1478 * Used to protect the incompat_flags, compat_flags, compat_ro_flags 1479 * when they are updated. 1480 * 1481 * Because we do not clear the flags for ever, so we needn't use 1482 * the lock on the read side. 1483 * 1484 * We also needn't use the lock when we mount the fs, because 1485 * there is no other task which will update the flag. 1486 */ 1487 spinlock_t super_lock; 1488 struct btrfs_super_block *super_copy; 1489 struct btrfs_super_block *super_for_commit; 1490 struct block_device *__bdev; 1491 struct super_block *sb; 1492 struct inode *btree_inode; 1493 struct backing_dev_info bdi; 1494 struct mutex tree_log_mutex; 1495 struct mutex transaction_kthread_mutex; 1496 struct mutex cleaner_mutex; 1497 struct mutex chunk_mutex; 1498 struct mutex volume_mutex; 1499 1500 /* 1501 * this is taken to make sure we don't set block groups ro after 1502 * the free space cache has been allocated on them 1503 */ 1504 struct mutex ro_block_group_mutex; 1505 1506 /* this is used during read/modify/write to make sure 1507 * no two ios are trying to mod the same stripe at the same 1508 * time 1509 */ 1510 struct btrfs_stripe_hash_table *stripe_hash_table; 1511 1512 /* 1513 * this protects the ordered operations list only while we are 1514 * processing all of the entries on it. This way we make 1515 * sure the commit code doesn't find the list temporarily empty 1516 * because another function happens to be doing non-waiting preflush 1517 * before jumping into the main commit. 1518 */ 1519 struct mutex ordered_operations_mutex; 1520 1521 /* 1522 * Same as ordered_operations_mutex except this is for ordered extents 1523 * and not the operations. 1524 */ 1525 struct mutex ordered_extent_flush_mutex; 1526 1527 struct rw_semaphore commit_root_sem; 1528 1529 struct rw_semaphore cleanup_work_sem; 1530 1531 struct rw_semaphore subvol_sem; 1532 struct srcu_struct subvol_srcu; 1533 1534 spinlock_t trans_lock; 1535 /* 1536 * the reloc mutex goes with the trans lock, it is taken 1537 * during commit to protect us from the relocation code 1538 */ 1539 struct mutex reloc_mutex; 1540 1541 struct list_head trans_list; 1542 struct list_head dead_roots; 1543 struct list_head caching_block_groups; 1544 1545 spinlock_t delayed_iput_lock; 1546 struct list_head delayed_iputs; 1547 struct rw_semaphore delayed_iput_sem; 1548 1549 /* this protects tree_mod_seq_list */ 1550 spinlock_t tree_mod_seq_lock; 1551 atomic64_t tree_mod_seq; 1552 struct list_head tree_mod_seq_list; 1553 1554 /* this protects tree_mod_log */ 1555 rwlock_t tree_mod_log_lock; 1556 struct rb_root tree_mod_log; 1557 1558 atomic_t nr_async_submits; 1559 atomic_t async_submit_draining; 1560 atomic_t nr_async_bios; 1561 atomic_t async_delalloc_pages; 1562 atomic_t open_ioctl_trans; 1563 1564 /* 1565 * this is used to protect the following list -- ordered_roots. 1566 */ 1567 spinlock_t ordered_root_lock; 1568 1569 /* 1570 * all fs/file tree roots in which there are data=ordered extents 1571 * pending writeback are added into this list. 1572 * 1573 * these can span multiple transactions and basically include 1574 * every dirty data page that isn't from nodatacow 1575 */ 1576 struct list_head ordered_roots; 1577 1578 struct mutex delalloc_root_mutex; 1579 spinlock_t delalloc_root_lock; 1580 /* all fs/file tree roots that have delalloc inodes. */ 1581 struct list_head delalloc_roots; 1582 1583 /* 1584 * there is a pool of worker threads for checksumming during writes 1585 * and a pool for checksumming after reads. This is because readers 1586 * can run with FS locks held, and the writers may be waiting for 1587 * those locks. We don't want ordering in the pending list to cause 1588 * deadlocks, and so the two are serviced separately. 1589 * 1590 * A third pool does submit_bio to avoid deadlocking with the other 1591 * two 1592 */ 1593 struct btrfs_workqueue *workers; 1594 struct btrfs_workqueue *delalloc_workers; 1595 struct btrfs_workqueue *flush_workers; 1596 struct btrfs_workqueue *endio_workers; 1597 struct btrfs_workqueue *endio_meta_workers; 1598 struct btrfs_workqueue *endio_raid56_workers; 1599 struct btrfs_workqueue *endio_repair_workers; 1600 struct btrfs_workqueue *rmw_workers; 1601 struct btrfs_workqueue *endio_meta_write_workers; 1602 struct btrfs_workqueue *endio_write_workers; 1603 struct btrfs_workqueue *endio_freespace_worker; 1604 struct btrfs_workqueue *submit_workers; 1605 struct btrfs_workqueue *caching_workers; 1606 struct btrfs_workqueue *readahead_workers; 1607 1608 /* 1609 * fixup workers take dirty pages that didn't properly go through 1610 * the cow mechanism and make them safe to write. It happens 1611 * for the sys_munmap function call path 1612 */ 1613 struct btrfs_workqueue *fixup_workers; 1614 struct btrfs_workqueue *delayed_workers; 1615 1616 /* the extent workers do delayed refs on the extent allocation tree */ 1617 struct btrfs_workqueue *extent_workers; 1618 struct task_struct *transaction_kthread; 1619 struct task_struct *cleaner_kthread; 1620 int thread_pool_size; 1621 1622 struct kobject *space_info_kobj; 1623 int do_barriers; 1624 int closing; 1625 int log_root_recovering; 1626 int open; 1627 1628 u64 total_pinned; 1629 1630 /* used to keep from writing metadata until there is a nice batch */ 1631 struct percpu_counter dirty_metadata_bytes; 1632 struct percpu_counter delalloc_bytes; 1633 s32 dirty_metadata_batch; 1634 s32 delalloc_batch; 1635 1636 struct list_head dirty_cowonly_roots; 1637 1638 struct btrfs_fs_devices *fs_devices; 1639 1640 /* 1641 * the space_info list is almost entirely read only. It only changes 1642 * when we add a new raid type to the FS, and that happens 1643 * very rarely. RCU is used to protect it. 1644 */ 1645 struct list_head space_info; 1646 1647 struct btrfs_space_info *data_sinfo; 1648 1649 struct reloc_control *reloc_ctl; 1650 1651 /* data_alloc_cluster is only used in ssd mode */ 1652 struct btrfs_free_cluster data_alloc_cluster; 1653 1654 /* all metadata allocations go through this cluster */ 1655 struct btrfs_free_cluster meta_alloc_cluster; 1656 1657 /* auto defrag inodes go here */ 1658 spinlock_t defrag_inodes_lock; 1659 struct rb_root defrag_inodes; 1660 atomic_t defrag_running; 1661 1662 /* Used to protect avail_{data, metadata, system}_alloc_bits */ 1663 seqlock_t profiles_lock; 1664 /* 1665 * these three are in extended format (availability of single 1666 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other 1667 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits) 1668 */ 1669 u64 avail_data_alloc_bits; 1670 u64 avail_metadata_alloc_bits; 1671 u64 avail_system_alloc_bits; 1672 1673 /* restriper state */ 1674 spinlock_t balance_lock; 1675 struct mutex balance_mutex; 1676 atomic_t balance_running; 1677 atomic_t balance_pause_req; 1678 atomic_t balance_cancel_req; 1679 struct btrfs_balance_control *balance_ctl; 1680 wait_queue_head_t balance_wait_q; 1681 1682 unsigned data_chunk_allocations; 1683 unsigned metadata_ratio; 1684 1685 void *bdev_holder; 1686 1687 /* private scrub information */ 1688 struct mutex scrub_lock; 1689 atomic_t scrubs_running; 1690 atomic_t scrub_pause_req; 1691 atomic_t scrubs_paused; 1692 atomic_t scrub_cancel_req; 1693 wait_queue_head_t scrub_pause_wait; 1694 int scrub_workers_refcnt; 1695 struct btrfs_workqueue *scrub_workers; 1696 struct btrfs_workqueue *scrub_wr_completion_workers; 1697 struct btrfs_workqueue *scrub_nocow_workers; 1698 struct btrfs_workqueue *scrub_parity_workers; 1699 1700 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY 1701 u32 check_integrity_print_mask; 1702 #endif 1703 /* 1704 * quota information 1705 */ 1706 unsigned int quota_enabled:1; 1707 1708 /* 1709 * quota_enabled only changes state after a commit. This holds the 1710 * next state. 1711 */ 1712 unsigned int pending_quota_state:1; 1713 1714 /* is qgroup tracking in a consistent state? */ 1715 u64 qgroup_flags; 1716 1717 /* holds configuration and tracking. Protected by qgroup_lock */ 1718 struct rb_root qgroup_tree; 1719 struct rb_root qgroup_op_tree; 1720 spinlock_t qgroup_lock; 1721 spinlock_t qgroup_op_lock; 1722 atomic_t qgroup_op_seq; 1723 1724 /* 1725 * used to avoid frequently calling ulist_alloc()/ulist_free() 1726 * when doing qgroup accounting, it must be protected by qgroup_lock. 1727 */ 1728 struct ulist *qgroup_ulist; 1729 1730 /* protect user change for quota operations */ 1731 struct mutex qgroup_ioctl_lock; 1732 1733 /* list of dirty qgroups to be written at next commit */ 1734 struct list_head dirty_qgroups; 1735 1736 /* used by qgroup for an efficient tree traversal */ 1737 u64 qgroup_seq; 1738 1739 /* qgroup rescan items */ 1740 struct mutex qgroup_rescan_lock; /* protects the progress item */ 1741 struct btrfs_key qgroup_rescan_progress; 1742 struct btrfs_workqueue *qgroup_rescan_workers; 1743 struct completion qgroup_rescan_completion; 1744 struct btrfs_work qgroup_rescan_work; 1745 1746 /* filesystem state */ 1747 unsigned long fs_state; 1748 1749 struct btrfs_delayed_root *delayed_root; 1750 1751 /* readahead tree */ 1752 spinlock_t reada_lock; 1753 struct radix_tree_root reada_tree; 1754 1755 /* Extent buffer radix tree */ 1756 spinlock_t buffer_lock; 1757 struct radix_tree_root buffer_radix; 1758 1759 /* next backup root to be overwritten */ 1760 int backup_root_index; 1761 1762 int num_tolerated_disk_barrier_failures; 1763 1764 /* device replace state */ 1765 struct btrfs_dev_replace dev_replace; 1766 1767 atomic_t mutually_exclusive_operation_running; 1768 1769 struct percpu_counter bio_counter; 1770 wait_queue_head_t replace_wait; 1771 1772 struct semaphore uuid_tree_rescan_sem; 1773 unsigned int update_uuid_tree_gen:1; 1774 1775 /* Used to reclaim the metadata space in the background. */ 1776 struct work_struct async_reclaim_work; 1777 1778 spinlock_t unused_bgs_lock; 1779 struct list_head unused_bgs; 1780 struct mutex unused_bg_unpin_mutex; 1781 struct mutex delete_unused_bgs_mutex; 1782 1783 /* For btrfs to record security options */ 1784 struct security_mnt_opts security_opts; 1785 1786 /* 1787 * Chunks that can't be freed yet (under a trim/discard operation) 1788 * and will be latter freed. Protected by fs_info->chunk_mutex. 1789 */ 1790 struct list_head pinned_chunks; 1791 }; 1792 1793 struct btrfs_subvolume_writers { 1794 struct percpu_counter counter; 1795 wait_queue_head_t wait; 1796 }; 1797 1798 /* 1799 * The state of btrfs root 1800 */ 1801 /* 1802 * btrfs_record_root_in_trans is a multi-step process, 1803 * and it can race with the balancing code. But the 1804 * race is very small, and only the first time the root 1805 * is added to each transaction. So IN_TRANS_SETUP 1806 * is used to tell us when more checks are required 1807 */ 1808 #define BTRFS_ROOT_IN_TRANS_SETUP 0 1809 #define BTRFS_ROOT_REF_COWS 1 1810 #define BTRFS_ROOT_TRACK_DIRTY 2 1811 #define BTRFS_ROOT_IN_RADIX 3 1812 #define BTRFS_ROOT_DUMMY_ROOT 4 1813 #define BTRFS_ROOT_ORPHAN_ITEM_INSERTED 5 1814 #define BTRFS_ROOT_DEFRAG_RUNNING 6 1815 #define BTRFS_ROOT_FORCE_COW 7 1816 #define BTRFS_ROOT_MULTI_LOG_TASKS 8 1817 #define BTRFS_ROOT_DIRTY 9 1818 1819 /* 1820 * in ram representation of the tree. extent_root is used for all allocations 1821 * and for the extent tree extent_root root. 1822 */ 1823 struct btrfs_root { 1824 struct extent_buffer *node; 1825 1826 struct extent_buffer *commit_root; 1827 struct btrfs_root *log_root; 1828 struct btrfs_root *reloc_root; 1829 1830 unsigned long state; 1831 struct btrfs_root_item root_item; 1832 struct btrfs_key root_key; 1833 struct btrfs_fs_info *fs_info; 1834 struct extent_io_tree dirty_log_pages; 1835 1836 struct mutex objectid_mutex; 1837 1838 spinlock_t accounting_lock; 1839 struct btrfs_block_rsv *block_rsv; 1840 1841 /* free ino cache stuff */ 1842 struct btrfs_free_space_ctl *free_ino_ctl; 1843 enum btrfs_caching_type ino_cache_state; 1844 spinlock_t ino_cache_lock; 1845 wait_queue_head_t ino_cache_wait; 1846 struct btrfs_free_space_ctl *free_ino_pinned; 1847 u64 ino_cache_progress; 1848 struct inode *ino_cache_inode; 1849 1850 struct mutex log_mutex; 1851 wait_queue_head_t log_writer_wait; 1852 wait_queue_head_t log_commit_wait[2]; 1853 struct list_head log_ctxs[2]; 1854 atomic_t log_writers; 1855 atomic_t log_commit[2]; 1856 atomic_t log_batch; 1857 int log_transid; 1858 /* No matter the commit succeeds or not*/ 1859 int log_transid_committed; 1860 /* Just be updated when the commit succeeds. */ 1861 int last_log_commit; 1862 pid_t log_start_pid; 1863 1864 u64 objectid; 1865 u64 last_trans; 1866 1867 /* data allocations are done in sectorsize units */ 1868 u32 sectorsize; 1869 1870 /* node allocations are done in nodesize units */ 1871 u32 nodesize; 1872 1873 u32 stripesize; 1874 1875 u32 type; 1876 1877 u64 highest_objectid; 1878 1879 /* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */ 1880 u64 alloc_bytenr; 1881 1882 u64 defrag_trans_start; 1883 struct btrfs_key defrag_progress; 1884 struct btrfs_key defrag_max; 1885 char *name; 1886 1887 /* the dirty list is only used by non-reference counted roots */ 1888 struct list_head dirty_list; 1889 1890 struct list_head root_list; 1891 1892 spinlock_t log_extents_lock[2]; 1893 struct list_head logged_list[2]; 1894 1895 spinlock_t orphan_lock; 1896 atomic_t orphan_inodes; 1897 struct btrfs_block_rsv *orphan_block_rsv; 1898 int orphan_cleanup_state; 1899 1900 spinlock_t inode_lock; 1901 /* red-black tree that keeps track of in-memory inodes */ 1902 struct rb_root inode_tree; 1903 1904 /* 1905 * radix tree that keeps track of delayed nodes of every inode, 1906 * protected by inode_lock 1907 */ 1908 struct radix_tree_root delayed_nodes_tree; 1909 /* 1910 * right now this just gets used so that a root has its own devid 1911 * for stat. It may be used for more later 1912 */ 1913 dev_t anon_dev; 1914 1915 spinlock_t root_item_lock; 1916 atomic_t refs; 1917 1918 struct mutex delalloc_mutex; 1919 spinlock_t delalloc_lock; 1920 /* 1921 * all of the inodes that have delalloc bytes. It is possible for 1922 * this list to be empty even when there is still dirty data=ordered 1923 * extents waiting to finish IO. 1924 */ 1925 struct list_head delalloc_inodes; 1926 struct list_head delalloc_root; 1927 u64 nr_delalloc_inodes; 1928 1929 struct mutex ordered_extent_mutex; 1930 /* 1931 * this is used by the balancing code to wait for all the pending 1932 * ordered extents 1933 */ 1934 spinlock_t ordered_extent_lock; 1935 1936 /* 1937 * all of the data=ordered extents pending writeback 1938 * these can span multiple transactions and basically include 1939 * every dirty data page that isn't from nodatacow 1940 */ 1941 struct list_head ordered_extents; 1942 struct list_head ordered_root; 1943 u64 nr_ordered_extents; 1944 1945 /* 1946 * Number of currently running SEND ioctls to prevent 1947 * manipulation with the read-only status via SUBVOL_SETFLAGS 1948 */ 1949 int send_in_progress; 1950 struct btrfs_subvolume_writers *subv_writers; 1951 atomic_t will_be_snapshoted; 1952 }; 1953 1954 struct btrfs_ioctl_defrag_range_args { 1955 /* start of the defrag operation */ 1956 __u64 start; 1957 1958 /* number of bytes to defrag, use (u64)-1 to say all */ 1959 __u64 len; 1960 1961 /* 1962 * flags for the operation, which can include turning 1963 * on compression for this one defrag 1964 */ 1965 __u64 flags; 1966 1967 /* 1968 * any extent bigger than this will be considered 1969 * already defragged. Use 0 to take the kernel default 1970 * Use 1 to say every single extent must be rewritten 1971 */ 1972 __u32 extent_thresh; 1973 1974 /* 1975 * which compression method to use if turning on compression 1976 * for this defrag operation. If unspecified, zlib will 1977 * be used 1978 */ 1979 __u32 compress_type; 1980 1981 /* spare for later */ 1982 __u32 unused[4]; 1983 }; 1984 1985 1986 /* 1987 * inode items have the data typically returned from stat and store other 1988 * info about object characteristics. There is one for every file and dir in 1989 * the FS 1990 */ 1991 #define BTRFS_INODE_ITEM_KEY 1 1992 #define BTRFS_INODE_REF_KEY 12 1993 #define BTRFS_INODE_EXTREF_KEY 13 1994 #define BTRFS_XATTR_ITEM_KEY 24 1995 #define BTRFS_ORPHAN_ITEM_KEY 48 1996 /* reserve 2-15 close to the inode for later flexibility */ 1997 1998 /* 1999 * dir items are the name -> inode pointers in a directory. There is one 2000 * for every name in a directory. 2001 */ 2002 #define BTRFS_DIR_LOG_ITEM_KEY 60 2003 #define BTRFS_DIR_LOG_INDEX_KEY 72 2004 #define BTRFS_DIR_ITEM_KEY 84 2005 #define BTRFS_DIR_INDEX_KEY 96 2006 /* 2007 * extent data is for file data 2008 */ 2009 #define BTRFS_EXTENT_DATA_KEY 108 2010 2011 /* 2012 * extent csums are stored in a separate tree and hold csums for 2013 * an entire extent on disk. 2014 */ 2015 #define BTRFS_EXTENT_CSUM_KEY 128 2016 2017 /* 2018 * root items point to tree roots. They are typically in the root 2019 * tree used by the super block to find all the other trees 2020 */ 2021 #define BTRFS_ROOT_ITEM_KEY 132 2022 2023 /* 2024 * root backrefs tie subvols and snapshots to the directory entries that 2025 * reference them 2026 */ 2027 #define BTRFS_ROOT_BACKREF_KEY 144 2028 2029 /* 2030 * root refs make a fast index for listing all of the snapshots and 2031 * subvolumes referenced by a given root. They point directly to the 2032 * directory item in the root that references the subvol 2033 */ 2034 #define BTRFS_ROOT_REF_KEY 156 2035 2036 /* 2037 * extent items are in the extent map tree. These record which blocks 2038 * are used, and how many references there are to each block 2039 */ 2040 #define BTRFS_EXTENT_ITEM_KEY 168 2041 2042 /* 2043 * The same as the BTRFS_EXTENT_ITEM_KEY, except it's metadata we already know 2044 * the length, so we save the level in key->offset instead of the length. 2045 */ 2046 #define BTRFS_METADATA_ITEM_KEY 169 2047 2048 #define BTRFS_TREE_BLOCK_REF_KEY 176 2049 2050 #define BTRFS_EXTENT_DATA_REF_KEY 178 2051 2052 #define BTRFS_EXTENT_REF_V0_KEY 180 2053 2054 #define BTRFS_SHARED_BLOCK_REF_KEY 182 2055 2056 #define BTRFS_SHARED_DATA_REF_KEY 184 2057 2058 /* 2059 * block groups give us hints into the extent allocation trees. Which 2060 * blocks are free etc etc 2061 */ 2062 #define BTRFS_BLOCK_GROUP_ITEM_KEY 192 2063 2064 #define BTRFS_DEV_EXTENT_KEY 204 2065 #define BTRFS_DEV_ITEM_KEY 216 2066 #define BTRFS_CHUNK_ITEM_KEY 228 2067 2068 /* 2069 * Records the overall state of the qgroups. 2070 * There's only one instance of this key present, 2071 * (0, BTRFS_QGROUP_STATUS_KEY, 0) 2072 */ 2073 #define BTRFS_QGROUP_STATUS_KEY 240 2074 /* 2075 * Records the currently used space of the qgroup. 2076 * One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid). 2077 */ 2078 #define BTRFS_QGROUP_INFO_KEY 242 2079 /* 2080 * Contains the user configured limits for the qgroup. 2081 * One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid). 2082 */ 2083 #define BTRFS_QGROUP_LIMIT_KEY 244 2084 /* 2085 * Records the child-parent relationship of qgroups. For 2086 * each relation, 2 keys are present: 2087 * (childid, BTRFS_QGROUP_RELATION_KEY, parentid) 2088 * (parentid, BTRFS_QGROUP_RELATION_KEY, childid) 2089 */ 2090 #define BTRFS_QGROUP_RELATION_KEY 246 2091 2092 #define BTRFS_BALANCE_ITEM_KEY 248 2093 2094 /* 2095 * Persistantly stores the io stats in the device tree. 2096 * One key for all stats, (0, BTRFS_DEV_STATS_KEY, devid). 2097 */ 2098 #define BTRFS_DEV_STATS_KEY 249 2099 2100 /* 2101 * Persistantly stores the device replace state in the device tree. 2102 * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0). 2103 */ 2104 #define BTRFS_DEV_REPLACE_KEY 250 2105 2106 /* 2107 * Stores items that allow to quickly map UUIDs to something else. 2108 * These items are part of the filesystem UUID tree. 2109 * The key is built like this: 2110 * (UUID_upper_64_bits, BTRFS_UUID_KEY*, UUID_lower_64_bits). 2111 */ 2112 #if BTRFS_UUID_SIZE != 16 2113 #error "UUID items require BTRFS_UUID_SIZE == 16!" 2114 #endif 2115 #define BTRFS_UUID_KEY_SUBVOL 251 /* for UUIDs assigned to subvols */ 2116 #define BTRFS_UUID_KEY_RECEIVED_SUBVOL 252 /* for UUIDs assigned to 2117 * received subvols */ 2118 2119 /* 2120 * string items are for debugging. They just store a short string of 2121 * data in the FS 2122 */ 2123 #define BTRFS_STRING_ITEM_KEY 253 2124 2125 /* 2126 * Flags for mount options. 2127 * 2128 * Note: don't forget to add new options to btrfs_show_options() 2129 */ 2130 #define BTRFS_MOUNT_NODATASUM (1 << 0) 2131 #define BTRFS_MOUNT_NODATACOW (1 << 1) 2132 #define BTRFS_MOUNT_NOBARRIER (1 << 2) 2133 #define BTRFS_MOUNT_SSD (1 << 3) 2134 #define BTRFS_MOUNT_DEGRADED (1 << 4) 2135 #define BTRFS_MOUNT_COMPRESS (1 << 5) 2136 #define BTRFS_MOUNT_NOTREELOG (1 << 6) 2137 #define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7) 2138 #define BTRFS_MOUNT_SSD_SPREAD (1 << 8) 2139 #define BTRFS_MOUNT_NOSSD (1 << 9) 2140 #define BTRFS_MOUNT_DISCARD (1 << 10) 2141 #define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11) 2142 #define BTRFS_MOUNT_SPACE_CACHE (1 << 12) 2143 #define BTRFS_MOUNT_CLEAR_CACHE (1 << 13) 2144 #define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14) 2145 #define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15) 2146 #define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16) 2147 #define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17) 2148 #define BTRFS_MOUNT_RECOVERY (1 << 18) 2149 #define BTRFS_MOUNT_SKIP_BALANCE (1 << 19) 2150 #define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20) 2151 #define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21) 2152 #define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22) 2153 #define BTRFS_MOUNT_RESCAN_UUID_TREE (1 << 23) 2154 2155 #define BTRFS_DEFAULT_COMMIT_INTERVAL (30) 2156 #define BTRFS_DEFAULT_MAX_INLINE (8192) 2157 2158 #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) 2159 #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) 2160 #define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt) 2161 #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \ 2162 BTRFS_MOUNT_##opt) 2163 2164 #define btrfs_set_and_info(root, opt, fmt, args...) \ 2165 { \ 2166 if (!btrfs_test_opt(root, opt)) \ 2167 btrfs_info(root->fs_info, fmt, ##args); \ 2168 btrfs_set_opt(root->fs_info->mount_opt, opt); \ 2169 } 2170 2171 #define btrfs_clear_and_info(root, opt, fmt, args...) \ 2172 { \ 2173 if (btrfs_test_opt(root, opt)) \ 2174 btrfs_info(root->fs_info, fmt, ##args); \ 2175 btrfs_clear_opt(root->fs_info->mount_opt, opt); \ 2176 } 2177 2178 /* 2179 * Requests for changes that need to be done during transaction commit. 2180 * 2181 * Internal mount options that are used for special handling of the real 2182 * mount options (eg. cannot be set during remount and have to be set during 2183 * transaction commit) 2184 */ 2185 2186 #define BTRFS_PENDING_SET_INODE_MAP_CACHE (0) 2187 #define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE (1) 2188 #define BTRFS_PENDING_COMMIT (2) 2189 2190 #define btrfs_test_pending(info, opt) \ 2191 test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes) 2192 #define btrfs_set_pending(info, opt) \ 2193 set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes) 2194 #define btrfs_clear_pending(info, opt) \ 2195 clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes) 2196 2197 /* 2198 * Helpers for setting pending mount option changes. 2199 * 2200 * Expects corresponding macros 2201 * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name 2202 */ 2203 #define btrfs_set_pending_and_info(info, opt, fmt, args...) \ 2204 do { \ 2205 if (!btrfs_raw_test_opt((info)->mount_opt, opt)) { \ 2206 btrfs_info((info), fmt, ##args); \ 2207 btrfs_set_pending((info), SET_##opt); \ 2208 btrfs_clear_pending((info), CLEAR_##opt); \ 2209 } \ 2210 } while(0) 2211 2212 #define btrfs_clear_pending_and_info(info, opt, fmt, args...) \ 2213 do { \ 2214 if (btrfs_raw_test_opt((info)->mount_opt, opt)) { \ 2215 btrfs_info((info), fmt, ##args); \ 2216 btrfs_set_pending((info), CLEAR_##opt); \ 2217 btrfs_clear_pending((info), SET_##opt); \ 2218 } \ 2219 } while(0) 2220 2221 /* 2222 * Inode flags 2223 */ 2224 #define BTRFS_INODE_NODATASUM (1 << 0) 2225 #define BTRFS_INODE_NODATACOW (1 << 1) 2226 #define BTRFS_INODE_READONLY (1 << 2) 2227 #define BTRFS_INODE_NOCOMPRESS (1 << 3) 2228 #define BTRFS_INODE_PREALLOC (1 << 4) 2229 #define BTRFS_INODE_SYNC (1 << 5) 2230 #define BTRFS_INODE_IMMUTABLE (1 << 6) 2231 #define BTRFS_INODE_APPEND (1 << 7) 2232 #define BTRFS_INODE_NODUMP (1 << 8) 2233 #define BTRFS_INODE_NOATIME (1 << 9) 2234 #define BTRFS_INODE_DIRSYNC (1 << 10) 2235 #define BTRFS_INODE_COMPRESS (1 << 11) 2236 2237 #define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31) 2238 2239 struct btrfs_map_token { 2240 struct extent_buffer *eb; 2241 char *kaddr; 2242 unsigned long offset; 2243 }; 2244 2245 static inline void btrfs_init_map_token (struct btrfs_map_token *token) 2246 { 2247 token->kaddr = NULL; 2248 } 2249 2250 /* some macros to generate set/get funcs for the struct fields. This 2251 * assumes there is a lefoo_to_cpu for every type, so lets make a simple 2252 * one for u8: 2253 */ 2254 #define le8_to_cpu(v) (v) 2255 #define cpu_to_le8(v) (v) 2256 #define __le8 u8 2257 2258 #define read_eb_member(eb, ptr, type, member, result) ( \ 2259 read_extent_buffer(eb, (char *)(result), \ 2260 ((unsigned long)(ptr)) + \ 2261 offsetof(type, member), \ 2262 sizeof(((type *)0)->member))) 2263 2264 #define write_eb_member(eb, ptr, type, member, result) ( \ 2265 write_extent_buffer(eb, (char *)(result), \ 2266 ((unsigned long)(ptr)) + \ 2267 offsetof(type, member), \ 2268 sizeof(((type *)0)->member))) 2269 2270 #define DECLARE_BTRFS_SETGET_BITS(bits) \ 2271 u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr, \ 2272 unsigned long off, \ 2273 struct btrfs_map_token *token); \ 2274 void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr, \ 2275 unsigned long off, u##bits val, \ 2276 struct btrfs_map_token *token); \ 2277 static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \ 2278 unsigned long off) \ 2279 { \ 2280 return btrfs_get_token_##bits(eb, ptr, off, NULL); \ 2281 } \ 2282 static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \ 2283 unsigned long off, u##bits val) \ 2284 { \ 2285 btrfs_set_token_##bits(eb, ptr, off, val, NULL); \ 2286 } 2287 2288 DECLARE_BTRFS_SETGET_BITS(8) 2289 DECLARE_BTRFS_SETGET_BITS(16) 2290 DECLARE_BTRFS_SETGET_BITS(32) 2291 DECLARE_BTRFS_SETGET_BITS(64) 2292 2293 #define BTRFS_SETGET_FUNCS(name, type, member, bits) \ 2294 static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s) \ 2295 { \ 2296 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \ 2297 return btrfs_get_##bits(eb, s, offsetof(type, member)); \ 2298 } \ 2299 static inline void btrfs_set_##name(struct extent_buffer *eb, type *s, \ 2300 u##bits val) \ 2301 { \ 2302 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \ 2303 btrfs_set_##bits(eb, s, offsetof(type, member), val); \ 2304 } \ 2305 static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \ 2306 struct btrfs_map_token *token) \ 2307 { \ 2308 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \ 2309 return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \ 2310 } \ 2311 static inline void btrfs_set_token_##name(struct extent_buffer *eb, \ 2312 type *s, u##bits val, \ 2313 struct btrfs_map_token *token) \ 2314 { \ 2315 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \ 2316 btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \ 2317 } 2318 2319 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \ 2320 static inline u##bits btrfs_##name(struct extent_buffer *eb) \ 2321 { \ 2322 type *p = page_address(eb->pages[0]); \ 2323 u##bits res = le##bits##_to_cpu(p->member); \ 2324 return res; \ 2325 } \ 2326 static inline void btrfs_set_##name(struct extent_buffer *eb, \ 2327 u##bits val) \ 2328 { \ 2329 type *p = page_address(eb->pages[0]); \ 2330 p->member = cpu_to_le##bits(val); \ 2331 } 2332 2333 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \ 2334 static inline u##bits btrfs_##name(type *s) \ 2335 { \ 2336 return le##bits##_to_cpu(s->member); \ 2337 } \ 2338 static inline void btrfs_set_##name(type *s, u##bits val) \ 2339 { \ 2340 s->member = cpu_to_le##bits(val); \ 2341 } 2342 2343 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64); 2344 BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64); 2345 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64); 2346 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32); 2347 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32); 2348 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item, 2349 start_offset, 64); 2350 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32); 2351 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64); 2352 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32); 2353 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8); 2354 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8); 2355 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64); 2356 2357 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64); 2358 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item, 2359 total_bytes, 64); 2360 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item, 2361 bytes_used, 64); 2362 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item, 2363 io_align, 32); 2364 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item, 2365 io_width, 32); 2366 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item, 2367 sector_size, 32); 2368 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64); 2369 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item, 2370 dev_group, 32); 2371 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item, 2372 seek_speed, 8); 2373 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item, 2374 bandwidth, 8); 2375 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item, 2376 generation, 64); 2377 2378 static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d) 2379 { 2380 return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid); 2381 } 2382 2383 static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d) 2384 { 2385 return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid); 2386 } 2387 2388 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64); 2389 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64); 2390 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64); 2391 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32); 2392 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32); 2393 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32); 2394 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64); 2395 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16); 2396 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16); 2397 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64); 2398 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64); 2399 2400 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s) 2401 { 2402 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid); 2403 } 2404 2405 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64); 2406 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64); 2407 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk, 2408 stripe_len, 64); 2409 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk, 2410 io_align, 32); 2411 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk, 2412 io_width, 32); 2413 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk, 2414 sector_size, 32); 2415 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64); 2416 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk, 2417 num_stripes, 16); 2418 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk, 2419 sub_stripes, 16); 2420 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64); 2421 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64); 2422 2423 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c, 2424 int nr) 2425 { 2426 unsigned long offset = (unsigned long)c; 2427 offset += offsetof(struct btrfs_chunk, stripe); 2428 offset += nr * sizeof(struct btrfs_stripe); 2429 return (struct btrfs_stripe *)offset; 2430 } 2431 2432 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr) 2433 { 2434 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr)); 2435 } 2436 2437 static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb, 2438 struct btrfs_chunk *c, int nr) 2439 { 2440 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr)); 2441 } 2442 2443 static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb, 2444 struct btrfs_chunk *c, int nr) 2445 { 2446 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr)); 2447 } 2448 2449 /* struct btrfs_block_group_item */ 2450 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item, 2451 used, 64); 2452 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item, 2453 used, 64); 2454 BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid, 2455 struct btrfs_block_group_item, chunk_objectid, 64); 2456 2457 BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid, 2458 struct btrfs_block_group_item, chunk_objectid, 64); 2459 BTRFS_SETGET_FUNCS(disk_block_group_flags, 2460 struct btrfs_block_group_item, flags, 64); 2461 BTRFS_SETGET_STACK_FUNCS(block_group_flags, 2462 struct btrfs_block_group_item, flags, 64); 2463 2464 /* struct btrfs_inode_ref */ 2465 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); 2466 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64); 2467 2468 /* struct btrfs_inode_extref */ 2469 BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref, 2470 parent_objectid, 64); 2471 BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref, 2472 name_len, 16); 2473 BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64); 2474 2475 /* struct btrfs_inode_item */ 2476 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64); 2477 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64); 2478 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64); 2479 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64); 2480 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64); 2481 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64); 2482 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32); 2483 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32); 2484 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32); 2485 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32); 2486 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64); 2487 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64); 2488 BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item, 2489 generation, 64); 2490 BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item, 2491 sequence, 64); 2492 BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item, 2493 transid, 64); 2494 BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64); 2495 BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item, 2496 nbytes, 64); 2497 BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item, 2498 block_group, 64); 2499 BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32); 2500 BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32); 2501 BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32); 2502 BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32); 2503 BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64); 2504 BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64); 2505 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64); 2506 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32); 2507 BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64); 2508 BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32); 2509 2510 /* struct btrfs_dev_extent */ 2511 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent, 2512 chunk_tree, 64); 2513 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent, 2514 chunk_objectid, 64); 2515 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent, 2516 chunk_offset, 64); 2517 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64); 2518 2519 static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev) 2520 { 2521 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid); 2522 return (unsigned long)dev + ptr; 2523 } 2524 2525 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64); 2526 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item, 2527 generation, 64); 2528 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64); 2529 2530 BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32); 2531 2532 2533 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8); 2534 2535 static inline void btrfs_tree_block_key(struct extent_buffer *eb, 2536 struct btrfs_tree_block_info *item, 2537 struct btrfs_disk_key *key) 2538 { 2539 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key); 2540 } 2541 2542 static inline void btrfs_set_tree_block_key(struct extent_buffer *eb, 2543 struct btrfs_tree_block_info *item, 2544 struct btrfs_disk_key *key) 2545 { 2546 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key); 2547 } 2548 2549 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref, 2550 root, 64); 2551 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref, 2552 objectid, 64); 2553 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref, 2554 offset, 64); 2555 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref, 2556 count, 32); 2557 2558 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref, 2559 count, 32); 2560 2561 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref, 2562 type, 8); 2563 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref, 2564 offset, 64); 2565 2566 static inline u32 btrfs_extent_inline_ref_size(int type) 2567 { 2568 if (type == BTRFS_TREE_BLOCK_REF_KEY || 2569 type == BTRFS_SHARED_BLOCK_REF_KEY) 2570 return sizeof(struct btrfs_extent_inline_ref); 2571 if (type == BTRFS_SHARED_DATA_REF_KEY) 2572 return sizeof(struct btrfs_shared_data_ref) + 2573 sizeof(struct btrfs_extent_inline_ref); 2574 if (type == BTRFS_EXTENT_DATA_REF_KEY) 2575 return sizeof(struct btrfs_extent_data_ref) + 2576 offsetof(struct btrfs_extent_inline_ref, offset); 2577 BUG(); 2578 return 0; 2579 } 2580 2581 BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64); 2582 BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0, 2583 generation, 64); 2584 BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64); 2585 BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32); 2586 2587 /* struct btrfs_node */ 2588 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); 2589 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); 2590 BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr, 2591 blockptr, 64); 2592 BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr, 2593 generation, 64); 2594 2595 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) 2596 { 2597 unsigned long ptr; 2598 ptr = offsetof(struct btrfs_node, ptrs) + 2599 sizeof(struct btrfs_key_ptr) * nr; 2600 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr); 2601 } 2602 2603 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, 2604 int nr, u64 val) 2605 { 2606 unsigned long ptr; 2607 ptr = offsetof(struct btrfs_node, ptrs) + 2608 sizeof(struct btrfs_key_ptr) * nr; 2609 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val); 2610 } 2611 2612 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) 2613 { 2614 unsigned long ptr; 2615 ptr = offsetof(struct btrfs_node, ptrs) + 2616 sizeof(struct btrfs_key_ptr) * nr; 2617 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr); 2618 } 2619 2620 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, 2621 int nr, u64 val) 2622 { 2623 unsigned long ptr; 2624 ptr = offsetof(struct btrfs_node, ptrs) + 2625 sizeof(struct btrfs_key_ptr) * nr; 2626 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val); 2627 } 2628 2629 static inline unsigned long btrfs_node_key_ptr_offset(int nr) 2630 { 2631 return offsetof(struct btrfs_node, ptrs) + 2632 sizeof(struct btrfs_key_ptr) * nr; 2633 } 2634 2635 void btrfs_node_key(struct extent_buffer *eb, 2636 struct btrfs_disk_key *disk_key, int nr); 2637 2638 static inline void btrfs_set_node_key(struct extent_buffer *eb, 2639 struct btrfs_disk_key *disk_key, int nr) 2640 { 2641 unsigned long ptr; 2642 ptr = btrfs_node_key_ptr_offset(nr); 2643 write_eb_member(eb, (struct btrfs_key_ptr *)ptr, 2644 struct btrfs_key_ptr, key, disk_key); 2645 } 2646 2647 /* struct btrfs_item */ 2648 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32); 2649 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32); 2650 BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32); 2651 BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32); 2652 2653 static inline unsigned long btrfs_item_nr_offset(int nr) 2654 { 2655 return offsetof(struct btrfs_leaf, items) + 2656 sizeof(struct btrfs_item) * nr; 2657 } 2658 2659 static inline struct btrfs_item *btrfs_item_nr(int nr) 2660 { 2661 return (struct btrfs_item *)btrfs_item_nr_offset(nr); 2662 } 2663 2664 static inline u32 btrfs_item_end(struct extent_buffer *eb, 2665 struct btrfs_item *item) 2666 { 2667 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item); 2668 } 2669 2670 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) 2671 { 2672 return btrfs_item_end(eb, btrfs_item_nr(nr)); 2673 } 2674 2675 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr) 2676 { 2677 return btrfs_item_offset(eb, btrfs_item_nr(nr)); 2678 } 2679 2680 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) 2681 { 2682 return btrfs_item_size(eb, btrfs_item_nr(nr)); 2683 } 2684 2685 static inline void btrfs_item_key(struct extent_buffer *eb, 2686 struct btrfs_disk_key *disk_key, int nr) 2687 { 2688 struct btrfs_item *item = btrfs_item_nr(nr); 2689 read_eb_member(eb, item, struct btrfs_item, key, disk_key); 2690 } 2691 2692 static inline void btrfs_set_item_key(struct extent_buffer *eb, 2693 struct btrfs_disk_key *disk_key, int nr) 2694 { 2695 struct btrfs_item *item = btrfs_item_nr(nr); 2696 write_eb_member(eb, item, struct btrfs_item, key, disk_key); 2697 } 2698 2699 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64); 2700 2701 /* 2702 * struct btrfs_root_ref 2703 */ 2704 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64); 2705 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64); 2706 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16); 2707 2708 /* struct btrfs_dir_item */ 2709 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16); 2710 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8); 2711 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16); 2712 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64); 2713 BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8); 2714 BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item, 2715 data_len, 16); 2716 BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item, 2717 name_len, 16); 2718 BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item, 2719 transid, 64); 2720 2721 static inline void btrfs_dir_item_key(struct extent_buffer *eb, 2722 struct btrfs_dir_item *item, 2723 struct btrfs_disk_key *key) 2724 { 2725 read_eb_member(eb, item, struct btrfs_dir_item, location, key); 2726 } 2727 2728 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb, 2729 struct btrfs_dir_item *item, 2730 struct btrfs_disk_key *key) 2731 { 2732 write_eb_member(eb, item, struct btrfs_dir_item, location, key); 2733 } 2734 2735 BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header, 2736 num_entries, 64); 2737 BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header, 2738 num_bitmaps, 64); 2739 BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header, 2740 generation, 64); 2741 2742 static inline void btrfs_free_space_key(struct extent_buffer *eb, 2743 struct btrfs_free_space_header *h, 2744 struct btrfs_disk_key *key) 2745 { 2746 read_eb_member(eb, h, struct btrfs_free_space_header, location, key); 2747 } 2748 2749 static inline void btrfs_set_free_space_key(struct extent_buffer *eb, 2750 struct btrfs_free_space_header *h, 2751 struct btrfs_disk_key *key) 2752 { 2753 write_eb_member(eb, h, struct btrfs_free_space_header, location, key); 2754 } 2755 2756 /* struct btrfs_disk_key */ 2757 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key, 2758 objectid, 64); 2759 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64); 2760 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8); 2761 2762 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu, 2763 struct btrfs_disk_key *disk) 2764 { 2765 cpu->offset = le64_to_cpu(disk->offset); 2766 cpu->type = disk->type; 2767 cpu->objectid = le64_to_cpu(disk->objectid); 2768 } 2769 2770 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk, 2771 struct btrfs_key *cpu) 2772 { 2773 disk->offset = cpu_to_le64(cpu->offset); 2774 disk->type = cpu->type; 2775 disk->objectid = cpu_to_le64(cpu->objectid); 2776 } 2777 2778 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb, 2779 struct btrfs_key *key, int nr) 2780 { 2781 struct btrfs_disk_key disk_key; 2782 btrfs_node_key(eb, &disk_key, nr); 2783 btrfs_disk_key_to_cpu(key, &disk_key); 2784 } 2785 2786 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb, 2787 struct btrfs_key *key, int nr) 2788 { 2789 struct btrfs_disk_key disk_key; 2790 btrfs_item_key(eb, &disk_key, nr); 2791 btrfs_disk_key_to_cpu(key, &disk_key); 2792 } 2793 2794 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb, 2795 struct btrfs_dir_item *item, 2796 struct btrfs_key *key) 2797 { 2798 struct btrfs_disk_key disk_key; 2799 btrfs_dir_item_key(eb, item, &disk_key); 2800 btrfs_disk_key_to_cpu(key, &disk_key); 2801 } 2802 2803 2804 static inline u8 btrfs_key_type(struct btrfs_key *key) 2805 { 2806 return key->type; 2807 } 2808 2809 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val) 2810 { 2811 key->type = val; 2812 } 2813 2814 /* struct btrfs_header */ 2815 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64); 2816 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header, 2817 generation, 64); 2818 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64); 2819 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32); 2820 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64); 2821 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8); 2822 BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header, 2823 generation, 64); 2824 BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64); 2825 BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header, 2826 nritems, 32); 2827 BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64); 2828 2829 static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag) 2830 { 2831 return (btrfs_header_flags(eb) & flag) == flag; 2832 } 2833 2834 static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag) 2835 { 2836 u64 flags = btrfs_header_flags(eb); 2837 btrfs_set_header_flags(eb, flags | flag); 2838 return (flags & flag) == flag; 2839 } 2840 2841 static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag) 2842 { 2843 u64 flags = btrfs_header_flags(eb); 2844 btrfs_set_header_flags(eb, flags & ~flag); 2845 return (flags & flag) == flag; 2846 } 2847 2848 static inline int btrfs_header_backref_rev(struct extent_buffer *eb) 2849 { 2850 u64 flags = btrfs_header_flags(eb); 2851 return flags >> BTRFS_BACKREF_REV_SHIFT; 2852 } 2853 2854 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb, 2855 int rev) 2856 { 2857 u64 flags = btrfs_header_flags(eb); 2858 flags &= ~BTRFS_BACKREF_REV_MASK; 2859 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT; 2860 btrfs_set_header_flags(eb, flags); 2861 } 2862 2863 static inline unsigned long btrfs_header_fsid(void) 2864 { 2865 return offsetof(struct btrfs_header, fsid); 2866 } 2867 2868 static inline unsigned long btrfs_header_chunk_tree_uuid(struct extent_buffer *eb) 2869 { 2870 return offsetof(struct btrfs_header, chunk_tree_uuid); 2871 } 2872 2873 static inline int btrfs_is_leaf(struct extent_buffer *eb) 2874 { 2875 return btrfs_header_level(eb) == 0; 2876 } 2877 2878 /* struct btrfs_root_item */ 2879 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item, 2880 generation, 64); 2881 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32); 2882 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64); 2883 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8); 2884 2885 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item, 2886 generation, 64); 2887 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64); 2888 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8); 2889 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64); 2890 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32); 2891 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64); 2892 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64); 2893 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64); 2894 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item, 2895 last_snapshot, 64); 2896 BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item, 2897 generation_v2, 64); 2898 BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item, 2899 ctransid, 64); 2900 BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item, 2901 otransid, 64); 2902 BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item, 2903 stransid, 64); 2904 BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item, 2905 rtransid, 64); 2906 2907 static inline bool btrfs_root_readonly(struct btrfs_root *root) 2908 { 2909 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0; 2910 } 2911 2912 static inline bool btrfs_root_dead(struct btrfs_root *root) 2913 { 2914 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0; 2915 } 2916 2917 /* struct btrfs_root_backup */ 2918 BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup, 2919 tree_root, 64); 2920 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup, 2921 tree_root_gen, 64); 2922 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup, 2923 tree_root_level, 8); 2924 2925 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup, 2926 chunk_root, 64); 2927 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup, 2928 chunk_root_gen, 64); 2929 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup, 2930 chunk_root_level, 8); 2931 2932 BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup, 2933 extent_root, 64); 2934 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup, 2935 extent_root_gen, 64); 2936 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup, 2937 extent_root_level, 8); 2938 2939 BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup, 2940 fs_root, 64); 2941 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup, 2942 fs_root_gen, 64); 2943 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup, 2944 fs_root_level, 8); 2945 2946 BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup, 2947 dev_root, 64); 2948 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup, 2949 dev_root_gen, 64); 2950 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup, 2951 dev_root_level, 8); 2952 2953 BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup, 2954 csum_root, 64); 2955 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup, 2956 csum_root_gen, 64); 2957 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup, 2958 csum_root_level, 8); 2959 BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup, 2960 total_bytes, 64); 2961 BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup, 2962 bytes_used, 64); 2963 BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup, 2964 num_devices, 64); 2965 2966 /* struct btrfs_balance_item */ 2967 BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64); 2968 2969 static inline void btrfs_balance_data(struct extent_buffer *eb, 2970 struct btrfs_balance_item *bi, 2971 struct btrfs_disk_balance_args *ba) 2972 { 2973 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba); 2974 } 2975 2976 static inline void btrfs_set_balance_data(struct extent_buffer *eb, 2977 struct btrfs_balance_item *bi, 2978 struct btrfs_disk_balance_args *ba) 2979 { 2980 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba); 2981 } 2982 2983 static inline void btrfs_balance_meta(struct extent_buffer *eb, 2984 struct btrfs_balance_item *bi, 2985 struct btrfs_disk_balance_args *ba) 2986 { 2987 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba); 2988 } 2989 2990 static inline void btrfs_set_balance_meta(struct extent_buffer *eb, 2991 struct btrfs_balance_item *bi, 2992 struct btrfs_disk_balance_args *ba) 2993 { 2994 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba); 2995 } 2996 2997 static inline void btrfs_balance_sys(struct extent_buffer *eb, 2998 struct btrfs_balance_item *bi, 2999 struct btrfs_disk_balance_args *ba) 3000 { 3001 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba); 3002 } 3003 3004 static inline void btrfs_set_balance_sys(struct extent_buffer *eb, 3005 struct btrfs_balance_item *bi, 3006 struct btrfs_disk_balance_args *ba) 3007 { 3008 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba); 3009 } 3010 3011 static inline void 3012 btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu, 3013 struct btrfs_disk_balance_args *disk) 3014 { 3015 memset(cpu, 0, sizeof(*cpu)); 3016 3017 cpu->profiles = le64_to_cpu(disk->profiles); 3018 cpu->usage = le64_to_cpu(disk->usage); 3019 cpu->devid = le64_to_cpu(disk->devid); 3020 cpu->pstart = le64_to_cpu(disk->pstart); 3021 cpu->pend = le64_to_cpu(disk->pend); 3022 cpu->vstart = le64_to_cpu(disk->vstart); 3023 cpu->vend = le64_to_cpu(disk->vend); 3024 cpu->target = le64_to_cpu(disk->target); 3025 cpu->flags = le64_to_cpu(disk->flags); 3026 cpu->limit = le64_to_cpu(disk->limit); 3027 } 3028 3029 static inline void 3030 btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk, 3031 struct btrfs_balance_args *cpu) 3032 { 3033 memset(disk, 0, sizeof(*disk)); 3034 3035 disk->profiles = cpu_to_le64(cpu->profiles); 3036 disk->usage = cpu_to_le64(cpu->usage); 3037 disk->devid = cpu_to_le64(cpu->devid); 3038 disk->pstart = cpu_to_le64(cpu->pstart); 3039 disk->pend = cpu_to_le64(cpu->pend); 3040 disk->vstart = cpu_to_le64(cpu->vstart); 3041 disk->vend = cpu_to_le64(cpu->vend); 3042 disk->target = cpu_to_le64(cpu->target); 3043 disk->flags = cpu_to_le64(cpu->flags); 3044 disk->limit = cpu_to_le64(cpu->limit); 3045 } 3046 3047 /* struct btrfs_super_block */ 3048 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64); 3049 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64); 3050 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block, 3051 generation, 64); 3052 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64); 3053 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size, 3054 struct btrfs_super_block, sys_chunk_array_size, 32); 3055 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation, 3056 struct btrfs_super_block, chunk_root_generation, 64); 3057 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block, 3058 root_level, 8); 3059 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block, 3060 chunk_root, 64); 3061 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block, 3062 chunk_root_level, 8); 3063 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block, 3064 log_root, 64); 3065 BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block, 3066 log_root_transid, 64); 3067 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block, 3068 log_root_level, 8); 3069 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block, 3070 total_bytes, 64); 3071 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block, 3072 bytes_used, 64); 3073 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block, 3074 sectorsize, 32); 3075 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block, 3076 nodesize, 32); 3077 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block, 3078 stripesize, 32); 3079 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block, 3080 root_dir_objectid, 64); 3081 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block, 3082 num_devices, 64); 3083 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block, 3084 compat_flags, 64); 3085 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block, 3086 compat_ro_flags, 64); 3087 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block, 3088 incompat_flags, 64); 3089 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block, 3090 csum_type, 16); 3091 BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block, 3092 cache_generation, 64); 3093 BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64); 3094 BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, 3095 uuid_tree_generation, 64); 3096 3097 static inline int btrfs_super_csum_size(struct btrfs_super_block *s) 3098 { 3099 u16 t = btrfs_super_csum_type(s); 3100 /* 3101 * csum type is validated at mount time 3102 */ 3103 return btrfs_csum_sizes[t]; 3104 } 3105 3106 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) 3107 { 3108 return offsetof(struct btrfs_leaf, items); 3109 } 3110 3111 /* struct btrfs_file_extent_item */ 3112 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8); 3113 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr, 3114 struct btrfs_file_extent_item, disk_bytenr, 64); 3115 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset, 3116 struct btrfs_file_extent_item, offset, 64); 3117 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation, 3118 struct btrfs_file_extent_item, generation, 64); 3119 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes, 3120 struct btrfs_file_extent_item, num_bytes, 64); 3121 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes, 3122 struct btrfs_file_extent_item, disk_num_bytes, 64); 3123 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression, 3124 struct btrfs_file_extent_item, compression, 8); 3125 3126 static inline unsigned long 3127 btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e) 3128 { 3129 return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START; 3130 } 3131 3132 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize) 3133 { 3134 return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize; 3135 } 3136 3137 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item, 3138 disk_bytenr, 64); 3139 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item, 3140 generation, 64); 3141 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item, 3142 disk_num_bytes, 64); 3143 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item, 3144 offset, 64); 3145 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item, 3146 num_bytes, 64); 3147 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item, 3148 ram_bytes, 64); 3149 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item, 3150 compression, 8); 3151 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item, 3152 encryption, 8); 3153 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item, 3154 other_encoding, 16); 3155 3156 /* 3157 * this returns the number of bytes used by the item on disk, minus the 3158 * size of any extent headers. If a file is compressed on disk, this is 3159 * the compressed size 3160 */ 3161 static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb, 3162 struct btrfs_item *e) 3163 { 3164 return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START; 3165 } 3166 3167 /* this returns the number of file bytes represented by the inline item. 3168 * If an item is compressed, this is the uncompressed size 3169 */ 3170 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb, 3171 int slot, 3172 struct btrfs_file_extent_item *fi) 3173 { 3174 struct btrfs_map_token token; 3175 3176 btrfs_init_map_token(&token); 3177 /* 3178 * return the space used on disk if this item isn't 3179 * compressed or encoded 3180 */ 3181 if (btrfs_token_file_extent_compression(eb, fi, &token) == 0 && 3182 btrfs_token_file_extent_encryption(eb, fi, &token) == 0 && 3183 btrfs_token_file_extent_other_encoding(eb, fi, &token) == 0) { 3184 return btrfs_file_extent_inline_item_len(eb, 3185 btrfs_item_nr(slot)); 3186 } 3187 3188 /* otherwise use the ram bytes field */ 3189 return btrfs_token_file_extent_ram_bytes(eb, fi, &token); 3190 } 3191 3192 3193 /* btrfs_dev_stats_item */ 3194 static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb, 3195 struct btrfs_dev_stats_item *ptr, 3196 int index) 3197 { 3198 u64 val; 3199 3200 read_extent_buffer(eb, &val, 3201 offsetof(struct btrfs_dev_stats_item, values) + 3202 ((unsigned long)ptr) + (index * sizeof(u64)), 3203 sizeof(val)); 3204 return val; 3205 } 3206 3207 static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb, 3208 struct btrfs_dev_stats_item *ptr, 3209 int index, u64 val) 3210 { 3211 write_extent_buffer(eb, &val, 3212 offsetof(struct btrfs_dev_stats_item, values) + 3213 ((unsigned long)ptr) + (index * sizeof(u64)), 3214 sizeof(val)); 3215 } 3216 3217 /* btrfs_qgroup_status_item */ 3218 BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item, 3219 generation, 64); 3220 BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item, 3221 version, 64); 3222 BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item, 3223 flags, 64); 3224 BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item, 3225 rescan, 64); 3226 3227 /* btrfs_qgroup_info_item */ 3228 BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item, 3229 generation, 64); 3230 BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64); 3231 BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item, 3232 rfer_cmpr, 64); 3233 BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64); 3234 BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item, 3235 excl_cmpr, 64); 3236 3237 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation, 3238 struct btrfs_qgroup_info_item, generation, 64); 3239 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item, 3240 rfer, 64); 3241 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr, 3242 struct btrfs_qgroup_info_item, rfer_cmpr, 64); 3243 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item, 3244 excl, 64); 3245 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr, 3246 struct btrfs_qgroup_info_item, excl_cmpr, 64); 3247 3248 /* btrfs_qgroup_limit_item */ 3249 BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item, 3250 flags, 64); 3251 BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item, 3252 max_rfer, 64); 3253 BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item, 3254 max_excl, 64); 3255 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item, 3256 rsv_rfer, 64); 3257 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item, 3258 rsv_excl, 64); 3259 3260 /* btrfs_dev_replace_item */ 3261 BTRFS_SETGET_FUNCS(dev_replace_src_devid, 3262 struct btrfs_dev_replace_item, src_devid, 64); 3263 BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode, 3264 struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode, 3265 64); 3266 BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item, 3267 replace_state, 64); 3268 BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item, 3269 time_started, 64); 3270 BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item, 3271 time_stopped, 64); 3272 BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item, 3273 num_write_errors, 64); 3274 BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors, 3275 struct btrfs_dev_replace_item, num_uncorrectable_read_errors, 3276 64); 3277 BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item, 3278 cursor_left, 64); 3279 BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item, 3280 cursor_right, 64); 3281 3282 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid, 3283 struct btrfs_dev_replace_item, src_devid, 64); 3284 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode, 3285 struct btrfs_dev_replace_item, 3286 cont_reading_from_srcdev_mode, 64); 3287 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state, 3288 struct btrfs_dev_replace_item, replace_state, 64); 3289 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started, 3290 struct btrfs_dev_replace_item, time_started, 64); 3291 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped, 3292 struct btrfs_dev_replace_item, time_stopped, 64); 3293 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors, 3294 struct btrfs_dev_replace_item, num_write_errors, 64); 3295 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors, 3296 struct btrfs_dev_replace_item, 3297 num_uncorrectable_read_errors, 64); 3298 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left, 3299 struct btrfs_dev_replace_item, cursor_left, 64); 3300 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right, 3301 struct btrfs_dev_replace_item, cursor_right, 64); 3302 3303 static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb) 3304 { 3305 return sb->s_fs_info; 3306 } 3307 3308 /* helper function to cast into the data area of the leaf. */ 3309 #define btrfs_item_ptr(leaf, slot, type) \ 3310 ((type *)(btrfs_leaf_data(leaf) + \ 3311 btrfs_item_offset_nr(leaf, slot))) 3312 3313 #define btrfs_item_ptr_offset(leaf, slot) \ 3314 ((unsigned long)(btrfs_leaf_data(leaf) + \ 3315 btrfs_item_offset_nr(leaf, slot))) 3316 3317 static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info) 3318 { 3319 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) && 3320 (space_info->flags & BTRFS_BLOCK_GROUP_DATA)); 3321 } 3322 3323 static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping) 3324 { 3325 return mapping_gfp_mask(mapping) & ~__GFP_FS; 3326 } 3327 3328 /* extent-tree.c */ 3329 3330 u64 btrfs_csum_bytes_to_leaves(struct btrfs_root *root, u64 csum_bytes); 3331 3332 static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root, 3333 unsigned num_items) 3334 { 3335 return (root->nodesize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) * 3336 2 * num_items; 3337 } 3338 3339 /* 3340 * Doing a truncate won't result in new nodes or leaves, just what we need for 3341 * COW. 3342 */ 3343 static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root, 3344 unsigned num_items) 3345 { 3346 return root->nodesize * BTRFS_MAX_LEVEL * num_items; 3347 } 3348 3349 int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans, 3350 struct btrfs_root *root); 3351 int btrfs_check_space_for_delayed_refs(struct btrfs_trans_handle *trans, 3352 struct btrfs_root *root); 3353 void btrfs_put_block_group(struct btrfs_block_group_cache *cache); 3354 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, 3355 struct btrfs_root *root, unsigned long count); 3356 int btrfs_async_run_delayed_refs(struct btrfs_root *root, 3357 unsigned long count, int wait); 3358 int btrfs_lookup_data_extent(struct btrfs_root *root, u64 start, u64 len); 3359 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans, 3360 struct btrfs_root *root, u64 bytenr, 3361 u64 offset, int metadata, u64 *refs, u64 *flags); 3362 int btrfs_pin_extent(struct btrfs_root *root, 3363 u64 bytenr, u64 num, int reserved); 3364 int btrfs_pin_extent_for_log_replay(struct btrfs_root *root, 3365 u64 bytenr, u64 num_bytes); 3366 int btrfs_exclude_logged_extents(struct btrfs_root *root, 3367 struct extent_buffer *eb); 3368 int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans, 3369 struct btrfs_root *root, 3370 u64 objectid, u64 offset, u64 bytenr); 3371 struct btrfs_block_group_cache *btrfs_lookup_block_group( 3372 struct btrfs_fs_info *info, 3373 u64 bytenr); 3374 void btrfs_put_block_group(struct btrfs_block_group_cache *cache); 3375 int get_block_group_index(struct btrfs_block_group_cache *cache); 3376 struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, 3377 struct btrfs_root *root, u64 parent, 3378 u64 root_objectid, 3379 struct btrfs_disk_key *key, int level, 3380 u64 hint, u64 empty_size); 3381 void btrfs_free_tree_block(struct btrfs_trans_handle *trans, 3382 struct btrfs_root *root, 3383 struct extent_buffer *buf, 3384 u64 parent, int last_ref); 3385 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans, 3386 struct btrfs_root *root, 3387 u64 root_objectid, u64 owner, 3388 u64 offset, struct btrfs_key *ins); 3389 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans, 3390 struct btrfs_root *root, 3391 u64 root_objectid, u64 owner, u64 offset, 3392 struct btrfs_key *ins); 3393 int btrfs_reserve_extent(struct btrfs_root *root, u64 num_bytes, 3394 u64 min_alloc_size, u64 empty_size, u64 hint_byte, 3395 struct btrfs_key *ins, int is_data, int delalloc); 3396 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 3397 struct extent_buffer *buf, int full_backref); 3398 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 3399 struct extent_buffer *buf, int full_backref); 3400 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans, 3401 struct btrfs_root *root, 3402 u64 bytenr, u64 num_bytes, u64 flags, 3403 int level, int is_data); 3404 int btrfs_free_extent(struct btrfs_trans_handle *trans, 3405 struct btrfs_root *root, 3406 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid, 3407 u64 owner, u64 offset, int no_quota); 3408 3409 int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len, 3410 int delalloc); 3411 int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root, 3412 u64 start, u64 len); 3413 void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, 3414 struct btrfs_root *root); 3415 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, 3416 struct btrfs_root *root); 3417 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, 3418 struct btrfs_root *root, 3419 u64 bytenr, u64 num_bytes, u64 parent, 3420 u64 root_objectid, u64 owner, u64 offset, int no_quota); 3421 3422 int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans, 3423 struct btrfs_root *root); 3424 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 3425 struct btrfs_root *root); 3426 int btrfs_setup_space_cache(struct btrfs_trans_handle *trans, 3427 struct btrfs_root *root); 3428 int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr); 3429 int btrfs_free_block_groups(struct btrfs_fs_info *info); 3430 int btrfs_read_block_groups(struct btrfs_root *root); 3431 int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr); 3432 int btrfs_make_block_group(struct btrfs_trans_handle *trans, 3433 struct btrfs_root *root, u64 bytes_used, 3434 u64 type, u64 chunk_objectid, u64 chunk_offset, 3435 u64 size); 3436 int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 3437 struct btrfs_root *root, u64 group_start, 3438 struct extent_map *em); 3439 void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info); 3440 void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans, 3441 struct btrfs_root *root); 3442 u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data); 3443 void btrfs_clear_space_info_full(struct btrfs_fs_info *info); 3444 3445 enum btrfs_reserve_flush_enum { 3446 /* If we are in the transaction, we can't flush anything.*/ 3447 BTRFS_RESERVE_NO_FLUSH, 3448 /* 3449 * Flushing delalloc may cause deadlock somewhere, in this 3450 * case, use FLUSH LIMIT 3451 */ 3452 BTRFS_RESERVE_FLUSH_LIMIT, 3453 BTRFS_RESERVE_FLUSH_ALL, 3454 }; 3455 3456 int btrfs_check_data_free_space(struct inode *inode, u64 bytes, u64 write_bytes); 3457 void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes); 3458 void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans, 3459 struct btrfs_root *root); 3460 void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans); 3461 int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, 3462 struct inode *inode); 3463 void btrfs_orphan_release_metadata(struct inode *inode); 3464 int btrfs_subvolume_reserve_metadata(struct btrfs_root *root, 3465 struct btrfs_block_rsv *rsv, 3466 int nitems, 3467 u64 *qgroup_reserved, bool use_global_rsv); 3468 void btrfs_subvolume_release_metadata(struct btrfs_root *root, 3469 struct btrfs_block_rsv *rsv, 3470 u64 qgroup_reserved); 3471 int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes); 3472 void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes); 3473 int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes); 3474 void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes); 3475 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type); 3476 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root, 3477 unsigned short type); 3478 void btrfs_free_block_rsv(struct btrfs_root *root, 3479 struct btrfs_block_rsv *rsv); 3480 void __btrfs_free_block_rsv(struct btrfs_block_rsv *rsv); 3481 int btrfs_block_rsv_add(struct btrfs_root *root, 3482 struct btrfs_block_rsv *block_rsv, u64 num_bytes, 3483 enum btrfs_reserve_flush_enum flush); 3484 int btrfs_block_rsv_check(struct btrfs_root *root, 3485 struct btrfs_block_rsv *block_rsv, int min_factor); 3486 int btrfs_block_rsv_refill(struct btrfs_root *root, 3487 struct btrfs_block_rsv *block_rsv, u64 min_reserved, 3488 enum btrfs_reserve_flush_enum flush); 3489 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv, 3490 struct btrfs_block_rsv *dst_rsv, 3491 u64 num_bytes); 3492 int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info, 3493 struct btrfs_block_rsv *dest, u64 num_bytes, 3494 int min_factor); 3495 void btrfs_block_rsv_release(struct btrfs_root *root, 3496 struct btrfs_block_rsv *block_rsv, 3497 u64 num_bytes); 3498 int btrfs_set_block_group_ro(struct btrfs_root *root, 3499 struct btrfs_block_group_cache *cache); 3500 void btrfs_set_block_group_rw(struct btrfs_root *root, 3501 struct btrfs_block_group_cache *cache); 3502 void btrfs_put_block_group_cache(struct btrfs_fs_info *info); 3503 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo); 3504 int btrfs_error_unpin_extent_range(struct btrfs_root *root, 3505 u64 start, u64 end); 3506 int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr, 3507 u64 num_bytes, u64 *actual_bytes); 3508 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, 3509 struct btrfs_root *root, u64 type); 3510 int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range); 3511 3512 int btrfs_init_space_info(struct btrfs_fs_info *fs_info); 3513 int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans, 3514 struct btrfs_fs_info *fs_info); 3515 int __get_raid_index(u64 flags); 3516 int btrfs_start_write_no_snapshoting(struct btrfs_root *root); 3517 void btrfs_end_write_no_snapshoting(struct btrfs_root *root); 3518 void check_system_chunk(struct btrfs_trans_handle *trans, 3519 struct btrfs_root *root, 3520 const u64 type); 3521 /* ctree.c */ 3522 int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key, 3523 int level, int *slot); 3524 int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2); 3525 int btrfs_previous_item(struct btrfs_root *root, 3526 struct btrfs_path *path, u64 min_objectid, 3527 int type); 3528 int btrfs_previous_extent_item(struct btrfs_root *root, 3529 struct btrfs_path *path, u64 min_objectid); 3530 void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info, 3531 struct btrfs_path *path, 3532 struct btrfs_key *new_key); 3533 struct extent_buffer *btrfs_root_node(struct btrfs_root *root); 3534 struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root); 3535 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path, 3536 struct btrfs_key *key, int lowest_level, 3537 u64 min_trans); 3538 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 3539 struct btrfs_path *path, 3540 u64 min_trans); 3541 enum btrfs_compare_tree_result { 3542 BTRFS_COMPARE_TREE_NEW, 3543 BTRFS_COMPARE_TREE_DELETED, 3544 BTRFS_COMPARE_TREE_CHANGED, 3545 BTRFS_COMPARE_TREE_SAME, 3546 }; 3547 typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root, 3548 struct btrfs_root *right_root, 3549 struct btrfs_path *left_path, 3550 struct btrfs_path *right_path, 3551 struct btrfs_key *key, 3552 enum btrfs_compare_tree_result result, 3553 void *ctx); 3554 int btrfs_compare_trees(struct btrfs_root *left_root, 3555 struct btrfs_root *right_root, 3556 btrfs_changed_cb_t cb, void *ctx); 3557 int btrfs_cow_block(struct btrfs_trans_handle *trans, 3558 struct btrfs_root *root, struct extent_buffer *buf, 3559 struct extent_buffer *parent, int parent_slot, 3560 struct extent_buffer **cow_ret); 3561 int btrfs_copy_root(struct btrfs_trans_handle *trans, 3562 struct btrfs_root *root, 3563 struct extent_buffer *buf, 3564 struct extent_buffer **cow_ret, u64 new_root_objectid); 3565 int btrfs_block_can_be_shared(struct btrfs_root *root, 3566 struct extent_buffer *buf); 3567 void btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path, 3568 u32 data_size); 3569 void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path, 3570 u32 new_size, int from_end); 3571 int btrfs_split_item(struct btrfs_trans_handle *trans, 3572 struct btrfs_root *root, 3573 struct btrfs_path *path, 3574 struct btrfs_key *new_key, 3575 unsigned long split_offset); 3576 int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 3577 struct btrfs_root *root, 3578 struct btrfs_path *path, 3579 struct btrfs_key *new_key); 3580 int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path, 3581 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key); 3582 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root 3583 *root, struct btrfs_key *key, struct btrfs_path *p, int 3584 ins_len, int cow); 3585 int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key, 3586 struct btrfs_path *p, u64 time_seq); 3587 int btrfs_search_slot_for_read(struct btrfs_root *root, 3588 struct btrfs_key *key, struct btrfs_path *p, 3589 int find_higher, int return_any); 3590 int btrfs_realloc_node(struct btrfs_trans_handle *trans, 3591 struct btrfs_root *root, struct extent_buffer *parent, 3592 int start_slot, u64 *last_ret, 3593 struct btrfs_key *progress); 3594 void btrfs_release_path(struct btrfs_path *p); 3595 struct btrfs_path *btrfs_alloc_path(void); 3596 void btrfs_free_path(struct btrfs_path *p); 3597 void btrfs_set_path_blocking(struct btrfs_path *p); 3598 void btrfs_clear_path_blocking(struct btrfs_path *p, 3599 struct extent_buffer *held, int held_rw); 3600 void btrfs_unlock_up_safe(struct btrfs_path *p, int level); 3601 3602 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 3603 struct btrfs_path *path, int slot, int nr); 3604 static inline int btrfs_del_item(struct btrfs_trans_handle *trans, 3605 struct btrfs_root *root, 3606 struct btrfs_path *path) 3607 { 3608 return btrfs_del_items(trans, root, path, path->slots[0], 1); 3609 } 3610 3611 void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path, 3612 struct btrfs_key *cpu_key, u32 *data_size, 3613 u32 total_data, u32 total_size, int nr); 3614 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root 3615 *root, struct btrfs_key *key, void *data, u32 data_size); 3616 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, 3617 struct btrfs_root *root, 3618 struct btrfs_path *path, 3619 struct btrfs_key *cpu_key, u32 *data_size, int nr); 3620 3621 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, 3622 struct btrfs_root *root, 3623 struct btrfs_path *path, 3624 struct btrfs_key *key, 3625 u32 data_size) 3626 { 3627 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1); 3628 } 3629 3630 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path); 3631 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); 3632 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path, 3633 u64 time_seq); 3634 static inline int btrfs_next_old_item(struct btrfs_root *root, 3635 struct btrfs_path *p, u64 time_seq) 3636 { 3637 ++p->slots[0]; 3638 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0])) 3639 return btrfs_next_old_leaf(root, p, time_seq); 3640 return 0; 3641 } 3642 static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p) 3643 { 3644 return btrfs_next_old_item(root, p, 0); 3645 } 3646 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); 3647 int __must_check btrfs_drop_snapshot(struct btrfs_root *root, 3648 struct btrfs_block_rsv *block_rsv, 3649 int update_ref, int for_reloc); 3650 int btrfs_drop_subtree(struct btrfs_trans_handle *trans, 3651 struct btrfs_root *root, 3652 struct extent_buffer *node, 3653 struct extent_buffer *parent); 3654 static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info) 3655 { 3656 /* 3657 * Get synced with close_ctree() 3658 */ 3659 smp_mb(); 3660 return fs_info->closing; 3661 } 3662 3663 /* 3664 * If we remount the fs to be R/O or umount the fs, the cleaner needn't do 3665 * anything except sleeping. This function is used to check the status of 3666 * the fs. 3667 */ 3668 static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root) 3669 { 3670 return (root->fs_info->sb->s_flags & MS_RDONLY || 3671 btrfs_fs_closing(root->fs_info)); 3672 } 3673 3674 static inline void free_fs_info(struct btrfs_fs_info *fs_info) 3675 { 3676 kfree(fs_info->balance_ctl); 3677 kfree(fs_info->delayed_root); 3678 kfree(fs_info->extent_root); 3679 kfree(fs_info->tree_root); 3680 kfree(fs_info->chunk_root); 3681 kfree(fs_info->dev_root); 3682 kfree(fs_info->csum_root); 3683 kfree(fs_info->quota_root); 3684 kfree(fs_info->uuid_root); 3685 kfree(fs_info->super_copy); 3686 kfree(fs_info->super_for_commit); 3687 security_free_mnt_opts(&fs_info->security_opts); 3688 kfree(fs_info); 3689 } 3690 3691 /* tree mod log functions from ctree.c */ 3692 u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info, 3693 struct seq_list *elem); 3694 void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info, 3695 struct seq_list *elem); 3696 int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq); 3697 3698 /* root-item.c */ 3699 int btrfs_find_root_ref(struct btrfs_root *tree_root, 3700 struct btrfs_path *path, 3701 u64 root_id, u64 ref_id); 3702 int btrfs_add_root_ref(struct btrfs_trans_handle *trans, 3703 struct btrfs_root *tree_root, 3704 u64 root_id, u64 ref_id, u64 dirid, u64 sequence, 3705 const char *name, int name_len); 3706 int btrfs_del_root_ref(struct btrfs_trans_handle *trans, 3707 struct btrfs_root *tree_root, 3708 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence, 3709 const char *name, int name_len); 3710 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, 3711 struct btrfs_key *key); 3712 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root 3713 *root, struct btrfs_key *key, struct btrfs_root_item 3714 *item); 3715 int __must_check btrfs_update_root(struct btrfs_trans_handle *trans, 3716 struct btrfs_root *root, 3717 struct btrfs_key *key, 3718 struct btrfs_root_item *item); 3719 int btrfs_find_root(struct btrfs_root *root, struct btrfs_key *search_key, 3720 struct btrfs_path *path, struct btrfs_root_item *root_item, 3721 struct btrfs_key *root_key); 3722 int btrfs_find_orphan_roots(struct btrfs_root *tree_root); 3723 void btrfs_set_root_node(struct btrfs_root_item *item, 3724 struct extent_buffer *node); 3725 void btrfs_check_and_init_root_item(struct btrfs_root_item *item); 3726 void btrfs_update_root_times(struct btrfs_trans_handle *trans, 3727 struct btrfs_root *root); 3728 3729 /* uuid-tree.c */ 3730 int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, 3731 struct btrfs_root *uuid_root, u8 *uuid, u8 type, 3732 u64 subid); 3733 int btrfs_uuid_tree_rem(struct btrfs_trans_handle *trans, 3734 struct btrfs_root *uuid_root, u8 *uuid, u8 type, 3735 u64 subid); 3736 int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info, 3737 int (*check_func)(struct btrfs_fs_info *, u8 *, u8, 3738 u64)); 3739 3740 /* dir-item.c */ 3741 int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir, 3742 const char *name, int name_len); 3743 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, 3744 struct btrfs_root *root, const char *name, 3745 int name_len, struct inode *dir, 3746 struct btrfs_key *location, u8 type, u64 index); 3747 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, 3748 struct btrfs_root *root, 3749 struct btrfs_path *path, u64 dir, 3750 const char *name, int name_len, 3751 int mod); 3752 struct btrfs_dir_item * 3753 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans, 3754 struct btrfs_root *root, 3755 struct btrfs_path *path, u64 dir, 3756 u64 objectid, const char *name, int name_len, 3757 int mod); 3758 struct btrfs_dir_item * 3759 btrfs_search_dir_index_item(struct btrfs_root *root, 3760 struct btrfs_path *path, u64 dirid, 3761 const char *name, int name_len); 3762 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, 3763 struct btrfs_root *root, 3764 struct btrfs_path *path, 3765 struct btrfs_dir_item *di); 3766 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, 3767 struct btrfs_root *root, 3768 struct btrfs_path *path, u64 objectid, 3769 const char *name, u16 name_len, 3770 const void *data, u16 data_len); 3771 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans, 3772 struct btrfs_root *root, 3773 struct btrfs_path *path, u64 dir, 3774 const char *name, u16 name_len, 3775 int mod); 3776 int verify_dir_item(struct btrfs_root *root, 3777 struct extent_buffer *leaf, 3778 struct btrfs_dir_item *dir_item); 3779 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, 3780 struct btrfs_path *path, 3781 const char *name, 3782 int name_len); 3783 3784 /* orphan.c */ 3785 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans, 3786 struct btrfs_root *root, u64 offset); 3787 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans, 3788 struct btrfs_root *root, u64 offset); 3789 int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset); 3790 3791 /* inode-item.c */ 3792 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, 3793 struct btrfs_root *root, 3794 const char *name, int name_len, 3795 u64 inode_objectid, u64 ref_objectid, u64 index); 3796 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 3797 struct btrfs_root *root, 3798 const char *name, int name_len, 3799 u64 inode_objectid, u64 ref_objectid, u64 *index); 3800 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, 3801 struct btrfs_root *root, 3802 struct btrfs_path *path, u64 objectid); 3803 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root 3804 *root, struct btrfs_path *path, 3805 struct btrfs_key *location, int mod); 3806 3807 struct btrfs_inode_extref * 3808 btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans, 3809 struct btrfs_root *root, 3810 struct btrfs_path *path, 3811 const char *name, int name_len, 3812 u64 inode_objectid, u64 ref_objectid, int ins_len, 3813 int cow); 3814 3815 int btrfs_find_name_in_ext_backref(struct btrfs_path *path, 3816 u64 ref_objectid, const char *name, 3817 int name_len, 3818 struct btrfs_inode_extref **extref_ret); 3819 3820 /* file-item.c */ 3821 struct btrfs_dio_private; 3822 int btrfs_del_csums(struct btrfs_trans_handle *trans, 3823 struct btrfs_root *root, u64 bytenr, u64 len); 3824 int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode, 3825 struct bio *bio, u32 *dst); 3826 int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode, 3827 struct bio *bio, u64 logical_offset); 3828 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 3829 struct btrfs_root *root, 3830 u64 objectid, u64 pos, 3831 u64 disk_offset, u64 disk_num_bytes, 3832 u64 num_bytes, u64 offset, u64 ram_bytes, 3833 u8 compression, u8 encryption, u16 other_encoding); 3834 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 3835 struct btrfs_root *root, 3836 struct btrfs_path *path, u64 objectid, 3837 u64 bytenr, int mod); 3838 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, 3839 struct btrfs_root *root, 3840 struct btrfs_ordered_sum *sums); 3841 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, 3842 struct bio *bio, u64 file_start, int contig); 3843 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 3844 struct list_head *list, int search_commit); 3845 void btrfs_extent_item_to_extent_map(struct inode *inode, 3846 const struct btrfs_path *path, 3847 struct btrfs_file_extent_item *fi, 3848 const bool new_inline, 3849 struct extent_map *em); 3850 3851 /* inode.c */ 3852 struct btrfs_delalloc_work { 3853 struct inode *inode; 3854 int wait; 3855 int delay_iput; 3856 struct completion completion; 3857 struct list_head list; 3858 struct btrfs_work work; 3859 }; 3860 3861 struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode, 3862 int wait, int delay_iput); 3863 void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work); 3864 3865 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page, 3866 size_t pg_offset, u64 start, u64 len, 3867 int create); 3868 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, 3869 u64 *orig_start, u64 *orig_block_len, 3870 u64 *ram_bytes); 3871 3872 /* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */ 3873 #if defined(ClearPageFsMisc) && !defined(ClearPageChecked) 3874 #define ClearPageChecked ClearPageFsMisc 3875 #define SetPageChecked SetPageFsMisc 3876 #define PageChecked PageFsMisc 3877 #endif 3878 3879 /* This forces readahead on a given range of bytes in an inode */ 3880 static inline void btrfs_force_ra(struct address_space *mapping, 3881 struct file_ra_state *ra, struct file *file, 3882 pgoff_t offset, unsigned long req_size) 3883 { 3884 page_cache_sync_readahead(mapping, ra, file, offset, req_size); 3885 } 3886 3887 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry); 3888 int btrfs_set_inode_index(struct inode *dir, u64 *index); 3889 int btrfs_unlink_inode(struct btrfs_trans_handle *trans, 3890 struct btrfs_root *root, 3891 struct inode *dir, struct inode *inode, 3892 const char *name, int name_len); 3893 int btrfs_add_link(struct btrfs_trans_handle *trans, 3894 struct inode *parent_inode, struct inode *inode, 3895 const char *name, int name_len, int add_backref, u64 index); 3896 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, 3897 struct btrfs_root *root, 3898 struct inode *dir, u64 objectid, 3899 const char *name, int name_len); 3900 int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len, 3901 int front); 3902 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, 3903 struct btrfs_root *root, 3904 struct inode *inode, u64 new_size, 3905 u32 min_type); 3906 3907 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput); 3908 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput, 3909 int nr); 3910 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end, 3911 struct extent_state **cached_state); 3912 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans, 3913 struct btrfs_root *new_root, 3914 struct btrfs_root *parent_root, 3915 u64 new_dirid); 3916 int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset, 3917 size_t size, struct bio *bio, 3918 unsigned long bio_flags); 3919 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf); 3920 int btrfs_readpage(struct file *file, struct page *page); 3921 void btrfs_evict_inode(struct inode *inode); 3922 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc); 3923 struct inode *btrfs_alloc_inode(struct super_block *sb); 3924 void btrfs_destroy_inode(struct inode *inode); 3925 int btrfs_drop_inode(struct inode *inode); 3926 int btrfs_init_cachep(void); 3927 void btrfs_destroy_cachep(void); 3928 long btrfs_ioctl_trans_end(struct file *file); 3929 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location, 3930 struct btrfs_root *root, int *was_new); 3931 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 3932 size_t pg_offset, u64 start, u64 end, 3933 int create); 3934 int btrfs_update_inode(struct btrfs_trans_handle *trans, 3935 struct btrfs_root *root, 3936 struct inode *inode); 3937 int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans, 3938 struct btrfs_root *root, struct inode *inode); 3939 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode); 3940 int btrfs_orphan_cleanup(struct btrfs_root *root); 3941 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, 3942 struct btrfs_root *root); 3943 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size); 3944 void btrfs_invalidate_inodes(struct btrfs_root *root); 3945 void btrfs_add_delayed_iput(struct inode *inode); 3946 void btrfs_run_delayed_iputs(struct btrfs_root *root); 3947 int btrfs_prealloc_file_range(struct inode *inode, int mode, 3948 u64 start, u64 num_bytes, u64 min_size, 3949 loff_t actual_len, u64 *alloc_hint); 3950 int btrfs_prealloc_file_range_trans(struct inode *inode, 3951 struct btrfs_trans_handle *trans, int mode, 3952 u64 start, u64 num_bytes, u64 min_size, 3953 loff_t actual_len, u64 *alloc_hint); 3954 int btrfs_inode_check_errors(struct inode *inode); 3955 extern const struct dentry_operations btrfs_dentry_operations; 3956 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 3957 void btrfs_test_inode_set_ops(struct inode *inode); 3958 #endif 3959 3960 /* ioctl.c */ 3961 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 3962 void btrfs_update_iflags(struct inode *inode); 3963 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir); 3964 int btrfs_is_empty_uuid(u8 *uuid); 3965 int btrfs_defrag_file(struct inode *inode, struct file *file, 3966 struct btrfs_ioctl_defrag_range_args *range, 3967 u64 newer_than, unsigned long max_pages); 3968 void btrfs_get_block_group_info(struct list_head *groups_list, 3969 struct btrfs_ioctl_space_info *space); 3970 void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock, 3971 struct btrfs_ioctl_balance_args *bargs); 3972 3973 3974 /* file.c */ 3975 int btrfs_auto_defrag_init(void); 3976 void btrfs_auto_defrag_exit(void); 3977 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 3978 struct inode *inode); 3979 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info); 3980 void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info); 3981 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync); 3982 void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 3983 int skip_pinned); 3984 extern const struct file_operations btrfs_file_operations; 3985 int __btrfs_drop_extents(struct btrfs_trans_handle *trans, 3986 struct btrfs_root *root, struct inode *inode, 3987 struct btrfs_path *path, u64 start, u64 end, 3988 u64 *drop_end, int drop_cache, 3989 int replace_extent, 3990 u32 extent_item_size, 3991 int *key_inserted); 3992 int btrfs_drop_extents(struct btrfs_trans_handle *trans, 3993 struct btrfs_root *root, struct inode *inode, u64 start, 3994 u64 end, int drop_cache); 3995 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 3996 struct inode *inode, u64 start, u64 end); 3997 int btrfs_release_file(struct inode *inode, struct file *file); 3998 int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode, 3999 struct page **pages, size_t num_pages, 4000 loff_t pos, size_t write_bytes, 4001 struct extent_state **cached); 4002 int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end); 4003 4004 /* tree-defrag.c */ 4005 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, 4006 struct btrfs_root *root); 4007 4008 /* sysfs.c */ 4009 int btrfs_init_sysfs(void); 4010 void btrfs_exit_sysfs(void); 4011 int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info); 4012 void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info); 4013 4014 /* xattr.c */ 4015 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size); 4016 4017 /* super.c */ 4018 int btrfs_parse_options(struct btrfs_root *root, char *options); 4019 int btrfs_sync_fs(struct super_block *sb, int wait); 4020 4021 #ifdef CONFIG_PRINTK 4022 __printf(2, 3) 4023 void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...); 4024 #else 4025 static inline __printf(2, 3) 4026 void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...) 4027 { 4028 } 4029 #endif 4030 4031 #define btrfs_emerg(fs_info, fmt, args...) \ 4032 btrfs_printk(fs_info, KERN_EMERG fmt, ##args) 4033 #define btrfs_alert(fs_info, fmt, args...) \ 4034 btrfs_printk(fs_info, KERN_ALERT fmt, ##args) 4035 #define btrfs_crit(fs_info, fmt, args...) \ 4036 btrfs_printk(fs_info, KERN_CRIT fmt, ##args) 4037 #define btrfs_err(fs_info, fmt, args...) \ 4038 btrfs_printk(fs_info, KERN_ERR fmt, ##args) 4039 #define btrfs_warn(fs_info, fmt, args...) \ 4040 btrfs_printk(fs_info, KERN_WARNING fmt, ##args) 4041 #define btrfs_notice(fs_info, fmt, args...) \ 4042 btrfs_printk(fs_info, KERN_NOTICE fmt, ##args) 4043 #define btrfs_info(fs_info, fmt, args...) \ 4044 btrfs_printk(fs_info, KERN_INFO fmt, ##args) 4045 4046 #ifdef DEBUG 4047 #define btrfs_debug(fs_info, fmt, args...) \ 4048 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args) 4049 #else 4050 #define btrfs_debug(fs_info, fmt, args...) \ 4051 no_printk(KERN_DEBUG fmt, ##args) 4052 #endif 4053 4054 #ifdef CONFIG_BTRFS_ASSERT 4055 4056 __cold 4057 static inline void assfail(char *expr, char *file, int line) 4058 { 4059 pr_err("BTRFS: assertion failed: %s, file: %s, line: %d", 4060 expr, file, line); 4061 BUG(); 4062 } 4063 4064 #define ASSERT(expr) \ 4065 (likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__)) 4066 #else 4067 #define ASSERT(expr) ((void)0) 4068 #endif 4069 4070 #define btrfs_assert() 4071 __printf(5, 6) 4072 __cold 4073 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, 4074 unsigned int line, int errno, const char *fmt, ...); 4075 4076 4077 __cold 4078 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans, 4079 struct btrfs_root *root, const char *function, 4080 unsigned int line, int errno); 4081 4082 #define btrfs_set_fs_incompat(__fs_info, opt) \ 4083 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt) 4084 4085 static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, 4086 u64 flag) 4087 { 4088 struct btrfs_super_block *disk_super; 4089 u64 features; 4090 4091 disk_super = fs_info->super_copy; 4092 features = btrfs_super_incompat_flags(disk_super); 4093 if (!(features & flag)) { 4094 spin_lock(&fs_info->super_lock); 4095 features = btrfs_super_incompat_flags(disk_super); 4096 if (!(features & flag)) { 4097 features |= flag; 4098 btrfs_set_super_incompat_flags(disk_super, features); 4099 btrfs_info(fs_info, "setting %llu feature flag", 4100 flag); 4101 } 4102 spin_unlock(&fs_info->super_lock); 4103 } 4104 } 4105 4106 #define btrfs_fs_incompat(fs_info, opt) \ 4107 __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt) 4108 4109 static inline int __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag) 4110 { 4111 struct btrfs_super_block *disk_super; 4112 disk_super = fs_info->super_copy; 4113 return !!(btrfs_super_incompat_flags(disk_super) & flag); 4114 } 4115 4116 /* 4117 * Call btrfs_abort_transaction as early as possible when an error condition is 4118 * detected, that way the exact line number is reported. 4119 */ 4120 #define btrfs_abort_transaction(trans, root, errno) \ 4121 do { \ 4122 /* Report first abort since mount */ \ 4123 if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED, \ 4124 &((root)->fs_info->fs_state))) { \ 4125 WARN(1, KERN_DEBUG \ 4126 "BTRFS: Transaction aborted (error %d)\n", \ 4127 (errno)); \ 4128 } \ 4129 __btrfs_abort_transaction((trans), (root), __func__, \ 4130 __LINE__, (errno)); \ 4131 } while (0) 4132 4133 #define btrfs_std_error(fs_info, errno) \ 4134 do { \ 4135 if ((errno)) \ 4136 __btrfs_std_error((fs_info), __func__, \ 4137 __LINE__, (errno), NULL); \ 4138 } while (0) 4139 4140 #define btrfs_error(fs_info, errno, fmt, args...) \ 4141 do { \ 4142 __btrfs_std_error((fs_info), __func__, __LINE__, \ 4143 (errno), fmt, ##args); \ 4144 } while (0) 4145 4146 __printf(5, 6) 4147 __cold 4148 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, 4149 unsigned int line, int errno, const char *fmt, ...); 4150 4151 /* 4152 * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic 4153 * will panic(). Otherwise we BUG() here. 4154 */ 4155 #define btrfs_panic(fs_info, errno, fmt, args...) \ 4156 do { \ 4157 __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \ 4158 BUG(); \ 4159 } while (0) 4160 4161 /* acl.c */ 4162 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 4163 struct posix_acl *btrfs_get_acl(struct inode *inode, int type); 4164 int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type); 4165 int btrfs_init_acl(struct btrfs_trans_handle *trans, 4166 struct inode *inode, struct inode *dir); 4167 #else 4168 #define btrfs_get_acl NULL 4169 #define btrfs_set_acl NULL 4170 static inline int btrfs_init_acl(struct btrfs_trans_handle *trans, 4171 struct inode *inode, struct inode *dir) 4172 { 4173 return 0; 4174 } 4175 #endif 4176 4177 /* relocation.c */ 4178 int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start); 4179 int btrfs_init_reloc_root(struct btrfs_trans_handle *trans, 4180 struct btrfs_root *root); 4181 int btrfs_update_reloc_root(struct btrfs_trans_handle *trans, 4182 struct btrfs_root *root); 4183 int btrfs_recover_relocation(struct btrfs_root *root); 4184 int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len); 4185 int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, 4186 struct btrfs_root *root, struct extent_buffer *buf, 4187 struct extent_buffer *cow); 4188 void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans, 4189 struct btrfs_pending_snapshot *pending, 4190 u64 *bytes_to_reserve); 4191 int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, 4192 struct btrfs_pending_snapshot *pending); 4193 4194 /* scrub.c */ 4195 int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, 4196 u64 end, struct btrfs_scrub_progress *progress, 4197 int readonly, int is_dev_replace); 4198 void btrfs_scrub_pause(struct btrfs_root *root); 4199 void btrfs_scrub_continue(struct btrfs_root *root); 4200 int btrfs_scrub_cancel(struct btrfs_fs_info *info); 4201 int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info, 4202 struct btrfs_device *dev); 4203 int btrfs_scrub_progress(struct btrfs_root *root, u64 devid, 4204 struct btrfs_scrub_progress *progress); 4205 4206 /* dev-replace.c */ 4207 void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info); 4208 void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info); 4209 void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount); 4210 4211 static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info) 4212 { 4213 btrfs_bio_counter_sub(fs_info, 1); 4214 } 4215 4216 /* reada.c */ 4217 struct reada_control { 4218 struct btrfs_root *root; /* tree to prefetch */ 4219 struct btrfs_key key_start; 4220 struct btrfs_key key_end; /* exclusive */ 4221 atomic_t elems; 4222 struct kref refcnt; 4223 wait_queue_head_t wait; 4224 }; 4225 struct reada_control *btrfs_reada_add(struct btrfs_root *root, 4226 struct btrfs_key *start, struct btrfs_key *end); 4227 int btrfs_reada_wait(void *handle); 4228 void btrfs_reada_detach(void *handle); 4229 int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb, 4230 u64 start, int err); 4231 4232 static inline int is_fstree(u64 rootid) 4233 { 4234 if (rootid == BTRFS_FS_TREE_OBJECTID || 4235 ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID && 4236 !btrfs_qgroup_level(rootid))) 4237 return 1; 4238 return 0; 4239 } 4240 4241 static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info) 4242 { 4243 return signal_pending(current); 4244 } 4245 4246 /* Sanity test specific functions */ 4247 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 4248 void btrfs_test_destroy_inode(struct inode *inode); 4249 #endif 4250 4251 static inline int btrfs_test_is_dummy_root(struct btrfs_root *root) 4252 { 4253 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 4254 if (unlikely(test_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state))) 4255 return 1; 4256 #endif 4257 return 0; 4258 } 4259 4260 #endif 4261