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