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/completion.h> 27 #include <linux/backing-dev.h> 28 #include <linux/wait.h> 29 #include <linux/slab.h> 30 #include <linux/kobject.h> 31 #include <trace/events/btrfs.h> 32 #include <asm/kmap_types.h> 33 #include "extent_io.h" 34 #include "extent_map.h" 35 #include "async-thread.h" 36 #include "ioctl.h" 37 38 struct btrfs_trans_handle; 39 struct btrfs_transaction; 40 struct btrfs_pending_snapshot; 41 extern struct kmem_cache *btrfs_trans_handle_cachep; 42 extern struct kmem_cache *btrfs_transaction_cachep; 43 extern struct kmem_cache *btrfs_bit_radix_cachep; 44 extern struct kmem_cache *btrfs_path_cachep; 45 extern struct kmem_cache *btrfs_free_space_cachep; 46 struct btrfs_ordered_sum; 47 48 #define BTRFS_MAGIC "_BHRfS_M" 49 50 #define BTRFS_MAX_LEVEL 8 51 52 #define BTRFS_COMPAT_EXTENT_TREE_V0 53 54 /* 55 * files bigger than this get some pre-flushing when they are added 56 * to the ordered operations list. That way we limit the total 57 * work done by the commit 58 */ 59 #define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024) 60 61 /* holds pointers to all of the tree roots */ 62 #define BTRFS_ROOT_TREE_OBJECTID 1ULL 63 64 /* stores information about which extents are in use, and reference counts */ 65 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL 66 67 /* 68 * chunk tree stores translations from logical -> physical block numbering 69 * the super block points to the chunk tree 70 */ 71 #define BTRFS_CHUNK_TREE_OBJECTID 3ULL 72 73 /* 74 * stores information about which areas of a given device are in use. 75 * one per device. The tree of tree roots points to the device tree 76 */ 77 #define BTRFS_DEV_TREE_OBJECTID 4ULL 78 79 /* one per subvolume, storing files and directories */ 80 #define BTRFS_FS_TREE_OBJECTID 5ULL 81 82 /* directory objectid inside the root tree */ 83 #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL 84 85 /* holds checksums of all the data extents */ 86 #define BTRFS_CSUM_TREE_OBJECTID 7ULL 87 88 /* orhpan objectid for tracking unlinked/truncated files */ 89 #define BTRFS_ORPHAN_OBJECTID -5ULL 90 91 /* does write ahead logging to speed up fsyncs */ 92 #define BTRFS_TREE_LOG_OBJECTID -6ULL 93 #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL 94 95 /* for space balancing */ 96 #define BTRFS_TREE_RELOC_OBJECTID -8ULL 97 #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL 98 99 /* 100 * extent checksums all have this objectid 101 * this allows them to share the logging tree 102 * for fsyncs 103 */ 104 #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL 105 106 /* For storing free space cache */ 107 #define BTRFS_FREE_SPACE_OBJECTID -11ULL 108 109 /* 110 * The inode number assigned to the special inode for sotring 111 * free ino cache 112 */ 113 #define BTRFS_FREE_INO_OBJECTID -12ULL 114 115 /* dummy objectid represents multiple objectids */ 116 #define BTRFS_MULTIPLE_OBJECTIDS -255ULL 117 118 /* 119 * All files have objectids in this range. 120 */ 121 #define BTRFS_FIRST_FREE_OBJECTID 256ULL 122 #define BTRFS_LAST_FREE_OBJECTID -256ULL 123 #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL 124 125 126 /* 127 * the device items go into the chunk tree. The key is in the form 128 * [ 1 BTRFS_DEV_ITEM_KEY device_id ] 129 */ 130 #define BTRFS_DEV_ITEMS_OBJECTID 1ULL 131 132 #define BTRFS_BTREE_INODE_OBJECTID 1 133 134 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2 135 136 /* 137 * we can actually store much bigger names, but lets not confuse the rest 138 * of linux 139 */ 140 #define BTRFS_NAME_LEN 255 141 142 /* 32 bytes in various csum fields */ 143 #define BTRFS_CSUM_SIZE 32 144 145 /* csum types */ 146 #define BTRFS_CSUM_TYPE_CRC32 0 147 148 static int btrfs_csum_sizes[] = { 4, 0 }; 149 150 /* four bytes for CRC32 */ 151 #define BTRFS_EMPTY_DIR_SIZE 0 152 153 #define BTRFS_FT_UNKNOWN 0 154 #define BTRFS_FT_REG_FILE 1 155 #define BTRFS_FT_DIR 2 156 #define BTRFS_FT_CHRDEV 3 157 #define BTRFS_FT_BLKDEV 4 158 #define BTRFS_FT_FIFO 5 159 #define BTRFS_FT_SOCK 6 160 #define BTRFS_FT_SYMLINK 7 161 #define BTRFS_FT_XATTR 8 162 #define BTRFS_FT_MAX 9 163 164 /* 165 * The key defines the order in the tree, and so it also defines (optimal) 166 * block layout. 167 * 168 * objectid corresponds to the inode number. 169 * 170 * type tells us things about the object, and is a kind of stream selector. 171 * so for a given inode, keys with type of 1 might refer to the inode data, 172 * type of 2 may point to file data in the btree and type == 3 may point to 173 * extents. 174 * 175 * offset is the starting byte offset for this key in the stream. 176 * 177 * btrfs_disk_key is in disk byte order. struct btrfs_key is always 178 * in cpu native order. Otherwise they are identical and their sizes 179 * should be the same (ie both packed) 180 */ 181 struct btrfs_disk_key { 182 __le64 objectid; 183 u8 type; 184 __le64 offset; 185 } __attribute__ ((__packed__)); 186 187 struct btrfs_key { 188 u64 objectid; 189 u8 type; 190 u64 offset; 191 } __attribute__ ((__packed__)); 192 193 struct btrfs_mapping_tree { 194 struct extent_map_tree map_tree; 195 }; 196 197 struct btrfs_dev_item { 198 /* the internal btrfs device id */ 199 __le64 devid; 200 201 /* size of the device */ 202 __le64 total_bytes; 203 204 /* bytes used */ 205 __le64 bytes_used; 206 207 /* optimal io alignment for this device */ 208 __le32 io_align; 209 210 /* optimal io width for this device */ 211 __le32 io_width; 212 213 /* minimal io size for this device */ 214 __le32 sector_size; 215 216 /* type and info about this device */ 217 __le64 type; 218 219 /* expected generation for this device */ 220 __le64 generation; 221 222 /* 223 * starting byte of this partition on the device, 224 * to allow for stripe alignment in the future 225 */ 226 __le64 start_offset; 227 228 /* grouping information for allocation decisions */ 229 __le32 dev_group; 230 231 /* seek speed 0-100 where 100 is fastest */ 232 u8 seek_speed; 233 234 /* bandwidth 0-100 where 100 is fastest */ 235 u8 bandwidth; 236 237 /* btrfs generated uuid for this device */ 238 u8 uuid[BTRFS_UUID_SIZE]; 239 240 /* uuid of FS who owns this device */ 241 u8 fsid[BTRFS_UUID_SIZE]; 242 } __attribute__ ((__packed__)); 243 244 struct btrfs_stripe { 245 __le64 devid; 246 __le64 offset; 247 u8 dev_uuid[BTRFS_UUID_SIZE]; 248 } __attribute__ ((__packed__)); 249 250 struct btrfs_chunk { 251 /* size of this chunk in bytes */ 252 __le64 length; 253 254 /* objectid of the root referencing this chunk */ 255 __le64 owner; 256 257 __le64 stripe_len; 258 __le64 type; 259 260 /* optimal io alignment for this chunk */ 261 __le32 io_align; 262 263 /* optimal io width for this chunk */ 264 __le32 io_width; 265 266 /* minimal io size for this chunk */ 267 __le32 sector_size; 268 269 /* 2^16 stripes is quite a lot, a second limit is the size of a single 270 * item in the btree 271 */ 272 __le16 num_stripes; 273 274 /* sub stripes only matter for raid10 */ 275 __le16 sub_stripes; 276 struct btrfs_stripe stripe; 277 /* additional stripes go here */ 278 } __attribute__ ((__packed__)); 279 280 #define BTRFS_FREE_SPACE_EXTENT 1 281 #define BTRFS_FREE_SPACE_BITMAP 2 282 283 struct btrfs_free_space_entry { 284 __le64 offset; 285 __le64 bytes; 286 u8 type; 287 } __attribute__ ((__packed__)); 288 289 struct btrfs_free_space_header { 290 struct btrfs_disk_key location; 291 __le64 generation; 292 __le64 num_entries; 293 __le64 num_bitmaps; 294 } __attribute__ ((__packed__)); 295 296 static inline unsigned long btrfs_chunk_item_size(int num_stripes) 297 { 298 BUG_ON(num_stripes == 0); 299 return sizeof(struct btrfs_chunk) + 300 sizeof(struct btrfs_stripe) * (num_stripes - 1); 301 } 302 303 #define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0) 304 #define BTRFS_HEADER_FLAG_RELOC (1ULL << 1) 305 306 /* 307 * File system states 308 */ 309 310 /* Errors detected */ 311 #define BTRFS_SUPER_FLAG_ERROR (1ULL << 2) 312 313 #define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32) 314 #define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33) 315 316 #define BTRFS_BACKREF_REV_MAX 256 317 #define BTRFS_BACKREF_REV_SHIFT 56 318 #define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \ 319 BTRFS_BACKREF_REV_SHIFT) 320 321 #define BTRFS_OLD_BACKREF_REV 0 322 #define BTRFS_MIXED_BACKREF_REV 1 323 324 /* 325 * every tree block (leaf or node) starts with this header. 326 */ 327 struct btrfs_header { 328 /* these first four must match the super block */ 329 u8 csum[BTRFS_CSUM_SIZE]; 330 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 331 __le64 bytenr; /* which block this node is supposed to live in */ 332 __le64 flags; 333 334 /* allowed to be different from the super from here on down */ 335 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 336 __le64 generation; 337 __le64 owner; 338 __le32 nritems; 339 u8 level; 340 } __attribute__ ((__packed__)); 341 342 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \ 343 sizeof(struct btrfs_header)) / \ 344 sizeof(struct btrfs_key_ptr)) 345 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header)) 346 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize)) 347 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ 348 sizeof(struct btrfs_item) - \ 349 sizeof(struct btrfs_file_extent_item)) 350 #define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ 351 sizeof(struct btrfs_item) -\ 352 sizeof(struct btrfs_dir_item)) 353 354 355 /* 356 * this is a very generous portion of the super block, giving us 357 * room to translate 14 chunks with 3 stripes each. 358 */ 359 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048 360 #define BTRFS_LABEL_SIZE 256 361 362 /* 363 * the super block basically lists the main trees of the FS 364 * it currently lacks any block count etc etc 365 */ 366 struct btrfs_super_block { 367 u8 csum[BTRFS_CSUM_SIZE]; 368 /* the first 4 fields must match struct btrfs_header */ 369 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 370 __le64 bytenr; /* this block number */ 371 __le64 flags; 372 373 /* allowed to be different from the btrfs_header from here own down */ 374 __le64 magic; 375 __le64 generation; 376 __le64 root; 377 __le64 chunk_root; 378 __le64 log_root; 379 380 /* this will help find the new super based on the log root */ 381 __le64 log_root_transid; 382 __le64 total_bytes; 383 __le64 bytes_used; 384 __le64 root_dir_objectid; 385 __le64 num_devices; 386 __le32 sectorsize; 387 __le32 nodesize; 388 __le32 leafsize; 389 __le32 stripesize; 390 __le32 sys_chunk_array_size; 391 __le64 chunk_root_generation; 392 __le64 compat_flags; 393 __le64 compat_ro_flags; 394 __le64 incompat_flags; 395 __le16 csum_type; 396 u8 root_level; 397 u8 chunk_root_level; 398 u8 log_root_level; 399 struct btrfs_dev_item dev_item; 400 401 char label[BTRFS_LABEL_SIZE]; 402 403 __le64 cache_generation; 404 405 /* future expansion */ 406 __le64 reserved[31]; 407 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; 408 } __attribute__ ((__packed__)); 409 410 /* 411 * Compat flags that we support. If any incompat flags are set other than the 412 * ones specified below then we will fail to mount 413 */ 414 #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0) 415 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1) 416 #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2) 417 #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3) 418 419 #define BTRFS_FEATURE_COMPAT_SUPP 0ULL 420 #define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL 421 #define BTRFS_FEATURE_INCOMPAT_SUPP \ 422 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \ 423 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \ 424 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \ 425 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO) 426 427 /* 428 * A leaf is full of items. offset and size tell us where to find 429 * the item in the leaf (relative to the start of the data area) 430 */ 431 struct btrfs_item { 432 struct btrfs_disk_key key; 433 __le32 offset; 434 __le32 size; 435 } __attribute__ ((__packed__)); 436 437 /* 438 * leaves have an item area and a data area: 439 * [item0, item1....itemN] [free space] [dataN...data1, data0] 440 * 441 * The data is separate from the items to get the keys closer together 442 * during searches. 443 */ 444 struct btrfs_leaf { 445 struct btrfs_header header; 446 struct btrfs_item items[]; 447 } __attribute__ ((__packed__)); 448 449 /* 450 * all non-leaf blocks are nodes, they hold only keys and pointers to 451 * other blocks 452 */ 453 struct btrfs_key_ptr { 454 struct btrfs_disk_key key; 455 __le64 blockptr; 456 __le64 generation; 457 } __attribute__ ((__packed__)); 458 459 struct btrfs_node { 460 struct btrfs_header header; 461 struct btrfs_key_ptr ptrs[]; 462 } __attribute__ ((__packed__)); 463 464 /* 465 * btrfs_paths remember the path taken from the root down to the leaf. 466 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point 467 * to any other levels that are present. 468 * 469 * The slots array records the index of the item or block pointer 470 * used while walking the tree. 471 */ 472 struct btrfs_path { 473 struct extent_buffer *nodes[BTRFS_MAX_LEVEL]; 474 int slots[BTRFS_MAX_LEVEL]; 475 /* if there is real range locking, this locks field will change */ 476 int locks[BTRFS_MAX_LEVEL]; 477 int reada; 478 /* keep some upper locks as we walk down */ 479 int lowest_level; 480 481 /* 482 * set by btrfs_split_item, tells search_slot to keep all locks 483 * and to force calls to keep space in the nodes 484 */ 485 unsigned int search_for_split:1; 486 unsigned int keep_locks:1; 487 unsigned int skip_locking:1; 488 unsigned int leave_spinning:1; 489 unsigned int search_commit_root:1; 490 }; 491 492 /* 493 * items in the extent btree are used to record the objectid of the 494 * owner of the block and the number of references 495 */ 496 497 struct btrfs_extent_item { 498 __le64 refs; 499 __le64 generation; 500 __le64 flags; 501 } __attribute__ ((__packed__)); 502 503 struct btrfs_extent_item_v0 { 504 __le32 refs; 505 } __attribute__ ((__packed__)); 506 507 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \ 508 sizeof(struct btrfs_item)) 509 510 #define BTRFS_EXTENT_FLAG_DATA (1ULL << 0) 511 #define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1) 512 513 /* following flags only apply to tree blocks */ 514 515 /* use full backrefs for extent pointers in the block */ 516 #define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8) 517 518 /* 519 * this flag is only used internally by scrub and may be changed at any time 520 * it is only declared here to avoid collisions 521 */ 522 #define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48) 523 524 struct btrfs_tree_block_info { 525 struct btrfs_disk_key key; 526 u8 level; 527 } __attribute__ ((__packed__)); 528 529 struct btrfs_extent_data_ref { 530 __le64 root; 531 __le64 objectid; 532 __le64 offset; 533 __le32 count; 534 } __attribute__ ((__packed__)); 535 536 struct btrfs_shared_data_ref { 537 __le32 count; 538 } __attribute__ ((__packed__)); 539 540 struct btrfs_extent_inline_ref { 541 u8 type; 542 __le64 offset; 543 } __attribute__ ((__packed__)); 544 545 /* old style backrefs item */ 546 struct btrfs_extent_ref_v0 { 547 __le64 root; 548 __le64 generation; 549 __le64 objectid; 550 __le32 count; 551 } __attribute__ ((__packed__)); 552 553 554 /* dev extents record free space on individual devices. The owner 555 * field points back to the chunk allocation mapping tree that allocated 556 * the extent. The chunk tree uuid field is a way to double check the owner 557 */ 558 struct btrfs_dev_extent { 559 __le64 chunk_tree; 560 __le64 chunk_objectid; 561 __le64 chunk_offset; 562 __le64 length; 563 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 564 } __attribute__ ((__packed__)); 565 566 struct btrfs_inode_ref { 567 __le64 index; 568 __le16 name_len; 569 /* name goes here */ 570 } __attribute__ ((__packed__)); 571 572 struct btrfs_timespec { 573 __le64 sec; 574 __le32 nsec; 575 } __attribute__ ((__packed__)); 576 577 enum btrfs_compression_type { 578 BTRFS_COMPRESS_NONE = 0, 579 BTRFS_COMPRESS_ZLIB = 1, 580 BTRFS_COMPRESS_LZO = 2, 581 BTRFS_COMPRESS_TYPES = 2, 582 BTRFS_COMPRESS_LAST = 3, 583 }; 584 585 struct btrfs_inode_item { 586 /* nfs style generation number */ 587 __le64 generation; 588 /* transid that last touched this inode */ 589 __le64 transid; 590 __le64 size; 591 __le64 nbytes; 592 __le64 block_group; 593 __le32 nlink; 594 __le32 uid; 595 __le32 gid; 596 __le32 mode; 597 __le64 rdev; 598 __le64 flags; 599 600 /* modification sequence number for NFS */ 601 __le64 sequence; 602 603 /* 604 * a little future expansion, for more than this we can 605 * just grow the inode item and version it 606 */ 607 __le64 reserved[4]; 608 struct btrfs_timespec atime; 609 struct btrfs_timespec ctime; 610 struct btrfs_timespec mtime; 611 struct btrfs_timespec otime; 612 } __attribute__ ((__packed__)); 613 614 struct btrfs_dir_log_item { 615 __le64 end; 616 } __attribute__ ((__packed__)); 617 618 struct btrfs_dir_item { 619 struct btrfs_disk_key location; 620 __le64 transid; 621 __le16 data_len; 622 __le16 name_len; 623 u8 type; 624 } __attribute__ ((__packed__)); 625 626 #define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0) 627 628 struct btrfs_root_item { 629 struct btrfs_inode_item inode; 630 __le64 generation; 631 __le64 root_dirid; 632 __le64 bytenr; 633 __le64 byte_limit; 634 __le64 bytes_used; 635 __le64 last_snapshot; 636 __le64 flags; 637 __le32 refs; 638 struct btrfs_disk_key drop_progress; 639 u8 drop_level; 640 u8 level; 641 } __attribute__ ((__packed__)); 642 643 /* 644 * this is used for both forward and backward root refs 645 */ 646 struct btrfs_root_ref { 647 __le64 dirid; 648 __le64 sequence; 649 __le16 name_len; 650 } __attribute__ ((__packed__)); 651 652 #define BTRFS_FILE_EXTENT_INLINE 0 653 #define BTRFS_FILE_EXTENT_REG 1 654 #define BTRFS_FILE_EXTENT_PREALLOC 2 655 656 struct btrfs_file_extent_item { 657 /* 658 * transaction id that created this extent 659 */ 660 __le64 generation; 661 /* 662 * max number of bytes to hold this extent in ram 663 * when we split a compressed extent we can't know how big 664 * each of the resulting pieces will be. So, this is 665 * an upper limit on the size of the extent in ram instead of 666 * an exact limit. 667 */ 668 __le64 ram_bytes; 669 670 /* 671 * 32 bits for the various ways we might encode the data, 672 * including compression and encryption. If any of these 673 * are set to something a given disk format doesn't understand 674 * it is treated like an incompat flag for reading and writing, 675 * but not for stat. 676 */ 677 u8 compression; 678 u8 encryption; 679 __le16 other_encoding; /* spare for later use */ 680 681 /* are we inline data or a real extent? */ 682 u8 type; 683 684 /* 685 * disk space consumed by the extent, checksum blocks are included 686 * in these numbers 687 */ 688 __le64 disk_bytenr; 689 __le64 disk_num_bytes; 690 /* 691 * the logical offset in file blocks (no csums) 692 * this extent record is for. This allows a file extent to point 693 * into the middle of an existing extent on disk, sharing it 694 * between two snapshots (useful if some bytes in the middle of the 695 * extent have changed 696 */ 697 __le64 offset; 698 /* 699 * the logical number of file blocks (no csums included). This 700 * always reflects the size uncompressed and without encoding. 701 */ 702 __le64 num_bytes; 703 704 } __attribute__ ((__packed__)); 705 706 struct btrfs_csum_item { 707 u8 csum; 708 } __attribute__ ((__packed__)); 709 710 /* different types of block groups (and chunks) */ 711 #define BTRFS_BLOCK_GROUP_DATA (1 << 0) 712 #define BTRFS_BLOCK_GROUP_SYSTEM (1 << 1) 713 #define BTRFS_BLOCK_GROUP_METADATA (1 << 2) 714 #define BTRFS_BLOCK_GROUP_RAID0 (1 << 3) 715 #define BTRFS_BLOCK_GROUP_RAID1 (1 << 4) 716 #define BTRFS_BLOCK_GROUP_DUP (1 << 5) 717 #define BTRFS_BLOCK_GROUP_RAID10 (1 << 6) 718 #define BTRFS_NR_RAID_TYPES 5 719 720 struct btrfs_block_group_item { 721 __le64 used; 722 __le64 chunk_objectid; 723 __le64 flags; 724 } __attribute__ ((__packed__)); 725 726 struct btrfs_space_info { 727 u64 flags; 728 729 u64 total_bytes; /* total bytes in the space, 730 this doesn't take mirrors into account */ 731 u64 bytes_used; /* total bytes used, 732 this doesn't take mirrors into account */ 733 u64 bytes_pinned; /* total bytes pinned, will be freed when the 734 transaction finishes */ 735 u64 bytes_reserved; /* total bytes the allocator has reserved for 736 current allocations */ 737 u64 bytes_readonly; /* total bytes that are read only */ 738 739 u64 bytes_may_use; /* number of bytes that may be used for 740 delalloc/allocations */ 741 u64 disk_used; /* total bytes used on disk */ 742 u64 disk_total; /* total bytes on disk, takes mirrors into 743 account */ 744 745 /* 746 * we bump reservation progress every time we decrement 747 * bytes_reserved. This way people waiting for reservations 748 * know something good has happened and they can check 749 * for progress. The number here isn't to be trusted, it 750 * just shows reclaim activity 751 */ 752 unsigned long reservation_progress; 753 754 unsigned int full:1; /* indicates that we cannot allocate any more 755 chunks for this space */ 756 unsigned int chunk_alloc:1; /* set if we are allocating a chunk */ 757 758 unsigned int flush:1; /* set if we are trying to make space */ 759 760 unsigned int force_alloc; /* set if we need to force a chunk 761 alloc for this space */ 762 763 struct list_head list; 764 765 /* for block groups in our same type */ 766 struct list_head block_groups[BTRFS_NR_RAID_TYPES]; 767 spinlock_t lock; 768 struct rw_semaphore groups_sem; 769 wait_queue_head_t wait; 770 }; 771 772 struct btrfs_block_rsv { 773 u64 size; 774 u64 reserved; 775 u64 freed[2]; 776 struct btrfs_space_info *space_info; 777 struct list_head list; 778 spinlock_t lock; 779 atomic_t usage; 780 unsigned int priority:8; 781 unsigned int durable:1; 782 unsigned int refill_used:1; 783 unsigned int full:1; 784 }; 785 786 /* 787 * free clusters are used to claim free space in relatively large chunks, 788 * allowing us to do less seeky writes. They are used for all metadata 789 * allocations and data allocations in ssd mode. 790 */ 791 struct btrfs_free_cluster { 792 spinlock_t lock; 793 spinlock_t refill_lock; 794 struct rb_root root; 795 796 /* largest extent in this cluster */ 797 u64 max_size; 798 799 /* first extent starting offset */ 800 u64 window_start; 801 802 struct btrfs_block_group_cache *block_group; 803 /* 804 * when a cluster is allocated from a block group, we put the 805 * cluster onto a list in the block group so that it can 806 * be freed before the block group is freed. 807 */ 808 struct list_head block_group_list; 809 }; 810 811 enum btrfs_caching_type { 812 BTRFS_CACHE_NO = 0, 813 BTRFS_CACHE_STARTED = 1, 814 BTRFS_CACHE_FINISHED = 2, 815 }; 816 817 enum btrfs_disk_cache_state { 818 BTRFS_DC_WRITTEN = 0, 819 BTRFS_DC_ERROR = 1, 820 BTRFS_DC_CLEAR = 2, 821 BTRFS_DC_SETUP = 3, 822 BTRFS_DC_NEED_WRITE = 4, 823 }; 824 825 struct btrfs_caching_control { 826 struct list_head list; 827 struct mutex mutex; 828 wait_queue_head_t wait; 829 struct btrfs_work work; 830 struct btrfs_block_group_cache *block_group; 831 u64 progress; 832 atomic_t count; 833 }; 834 835 struct btrfs_block_group_cache { 836 struct btrfs_key key; 837 struct btrfs_block_group_item item; 838 struct btrfs_fs_info *fs_info; 839 struct inode *inode; 840 spinlock_t lock; 841 u64 pinned; 842 u64 reserved; 843 u64 reserved_pinned; 844 u64 bytes_super; 845 u64 flags; 846 u64 sectorsize; 847 unsigned int ro:1; 848 unsigned int dirty:1; 849 unsigned int iref:1; 850 851 int disk_cache_state; 852 853 /* cache tracking stuff */ 854 int cached; 855 struct btrfs_caching_control *caching_ctl; 856 u64 last_byte_to_unpin; 857 858 struct btrfs_space_info *space_info; 859 860 /* free space cache stuff */ 861 struct btrfs_free_space_ctl *free_space_ctl; 862 863 /* block group cache stuff */ 864 struct rb_node cache_node; 865 866 /* for block groups in the same raid type */ 867 struct list_head list; 868 869 /* usage count */ 870 atomic_t count; 871 872 /* List of struct btrfs_free_clusters for this block group. 873 * Today it will only have one thing on it, but that may change 874 */ 875 struct list_head cluster_list; 876 }; 877 878 struct reloc_control; 879 struct btrfs_device; 880 struct btrfs_fs_devices; 881 struct btrfs_delayed_root; 882 struct btrfs_fs_info { 883 u8 fsid[BTRFS_FSID_SIZE]; 884 u8 chunk_tree_uuid[BTRFS_UUID_SIZE]; 885 struct btrfs_root *extent_root; 886 struct btrfs_root *tree_root; 887 struct btrfs_root *chunk_root; 888 struct btrfs_root *dev_root; 889 struct btrfs_root *fs_root; 890 struct btrfs_root *csum_root; 891 892 /* the log root tree is a directory of all the other log roots */ 893 struct btrfs_root *log_root_tree; 894 895 spinlock_t fs_roots_radix_lock; 896 struct radix_tree_root fs_roots_radix; 897 898 /* block group cache stuff */ 899 spinlock_t block_group_cache_lock; 900 struct rb_root block_group_cache_tree; 901 902 struct extent_io_tree freed_extents[2]; 903 struct extent_io_tree *pinned_extents; 904 905 /* logical->physical extent mapping */ 906 struct btrfs_mapping_tree mapping_tree; 907 908 /* 909 * block reservation for extent, checksum, root tree and 910 * delayed dir index item 911 */ 912 struct btrfs_block_rsv global_block_rsv; 913 /* block reservation for delay allocation */ 914 struct btrfs_block_rsv delalloc_block_rsv; 915 /* block reservation for metadata operations */ 916 struct btrfs_block_rsv trans_block_rsv; 917 /* block reservation for chunk tree */ 918 struct btrfs_block_rsv chunk_block_rsv; 919 920 struct btrfs_block_rsv empty_block_rsv; 921 922 /* list of block reservations that cross multiple transactions */ 923 struct list_head durable_block_rsv_list; 924 925 struct mutex durable_block_rsv_mutex; 926 927 u64 generation; 928 u64 last_trans_committed; 929 930 /* 931 * this is updated to the current trans every time a full commit 932 * is required instead of the faster short fsync log commits 933 */ 934 u64 last_trans_log_full_commit; 935 unsigned long mount_opt:20; 936 unsigned long compress_type:4; 937 u64 max_inline; 938 u64 alloc_start; 939 struct btrfs_transaction *running_transaction; 940 wait_queue_head_t transaction_throttle; 941 wait_queue_head_t transaction_wait; 942 wait_queue_head_t transaction_blocked_wait; 943 wait_queue_head_t async_submit_wait; 944 945 struct btrfs_super_block super_copy; 946 struct btrfs_super_block super_for_commit; 947 struct block_device *__bdev; 948 struct super_block *sb; 949 struct inode *btree_inode; 950 struct backing_dev_info bdi; 951 struct mutex tree_log_mutex; 952 struct mutex transaction_kthread_mutex; 953 struct mutex cleaner_mutex; 954 struct mutex chunk_mutex; 955 struct mutex volume_mutex; 956 /* 957 * this protects the ordered operations list only while we are 958 * processing all of the entries on it. This way we make 959 * sure the commit code doesn't find the list temporarily empty 960 * because another function happens to be doing non-waiting preflush 961 * before jumping into the main commit. 962 */ 963 struct mutex ordered_operations_mutex; 964 struct rw_semaphore extent_commit_sem; 965 966 struct rw_semaphore cleanup_work_sem; 967 968 struct rw_semaphore subvol_sem; 969 struct srcu_struct subvol_srcu; 970 971 spinlock_t trans_lock; 972 /* 973 * the reloc mutex goes with the trans lock, it is taken 974 * during commit to protect us from the relocation code 975 */ 976 struct mutex reloc_mutex; 977 978 struct list_head trans_list; 979 struct list_head hashers; 980 struct list_head dead_roots; 981 struct list_head caching_block_groups; 982 983 spinlock_t delayed_iput_lock; 984 struct list_head delayed_iputs; 985 986 atomic_t nr_async_submits; 987 atomic_t async_submit_draining; 988 atomic_t nr_async_bios; 989 atomic_t async_delalloc_pages; 990 atomic_t open_ioctl_trans; 991 992 /* 993 * this is used by the balancing code to wait for all the pending 994 * ordered extents 995 */ 996 spinlock_t ordered_extent_lock; 997 998 /* 999 * all of the data=ordered extents pending writeback 1000 * these can span multiple transactions and basically include 1001 * every dirty data page that isn't from nodatacow 1002 */ 1003 struct list_head ordered_extents; 1004 1005 /* 1006 * all of the inodes that have delalloc bytes. It is possible for 1007 * this list to be empty even when there is still dirty data=ordered 1008 * extents waiting to finish IO. 1009 */ 1010 struct list_head delalloc_inodes; 1011 1012 /* 1013 * special rename and truncate targets that must be on disk before 1014 * we're allowed to commit. This is basically the ext3 style 1015 * data=ordered list. 1016 */ 1017 struct list_head ordered_operations; 1018 1019 /* 1020 * there is a pool of worker threads for checksumming during writes 1021 * and a pool for checksumming after reads. This is because readers 1022 * can run with FS locks held, and the writers may be waiting for 1023 * those locks. We don't want ordering in the pending list to cause 1024 * deadlocks, and so the two are serviced separately. 1025 * 1026 * A third pool does submit_bio to avoid deadlocking with the other 1027 * two 1028 */ 1029 struct btrfs_workers generic_worker; 1030 struct btrfs_workers workers; 1031 struct btrfs_workers delalloc_workers; 1032 struct btrfs_workers endio_workers; 1033 struct btrfs_workers endio_meta_workers; 1034 struct btrfs_workers endio_meta_write_workers; 1035 struct btrfs_workers endio_write_workers; 1036 struct btrfs_workers endio_freespace_worker; 1037 struct btrfs_workers submit_workers; 1038 struct btrfs_workers caching_workers; 1039 1040 /* 1041 * fixup workers take dirty pages that didn't properly go through 1042 * the cow mechanism and make them safe to write. It happens 1043 * for the sys_munmap function call path 1044 */ 1045 struct btrfs_workers fixup_workers; 1046 struct btrfs_workers delayed_workers; 1047 struct task_struct *transaction_kthread; 1048 struct task_struct *cleaner_kthread; 1049 int thread_pool_size; 1050 1051 struct kobject super_kobj; 1052 struct completion kobj_unregister; 1053 int do_barriers; 1054 int closing; 1055 int log_root_recovering; 1056 int enospc_unlink; 1057 int trans_no_join; 1058 1059 u64 total_pinned; 1060 1061 /* protected by the delalloc lock, used to keep from writing 1062 * metadata until there is a nice batch 1063 */ 1064 u64 dirty_metadata_bytes; 1065 struct list_head dirty_cowonly_roots; 1066 1067 struct btrfs_fs_devices *fs_devices; 1068 1069 /* 1070 * the space_info list is almost entirely read only. It only changes 1071 * when we add a new raid type to the FS, and that happens 1072 * very rarely. RCU is used to protect it. 1073 */ 1074 struct list_head space_info; 1075 1076 struct reloc_control *reloc_ctl; 1077 1078 spinlock_t delalloc_lock; 1079 u64 delalloc_bytes; 1080 1081 /* data_alloc_cluster is only used in ssd mode */ 1082 struct btrfs_free_cluster data_alloc_cluster; 1083 1084 /* all metadata allocations go through this cluster */ 1085 struct btrfs_free_cluster meta_alloc_cluster; 1086 1087 /* auto defrag inodes go here */ 1088 spinlock_t defrag_inodes_lock; 1089 struct rb_root defrag_inodes; 1090 atomic_t defrag_running; 1091 1092 spinlock_t ref_cache_lock; 1093 u64 total_ref_cache_size; 1094 1095 u64 avail_data_alloc_bits; 1096 u64 avail_metadata_alloc_bits; 1097 u64 avail_system_alloc_bits; 1098 u64 data_alloc_profile; 1099 u64 metadata_alloc_profile; 1100 u64 system_alloc_profile; 1101 1102 unsigned data_chunk_allocations; 1103 unsigned metadata_ratio; 1104 1105 void *bdev_holder; 1106 1107 /* private scrub information */ 1108 struct mutex scrub_lock; 1109 atomic_t scrubs_running; 1110 atomic_t scrub_pause_req; 1111 atomic_t scrubs_paused; 1112 atomic_t scrub_cancel_req; 1113 wait_queue_head_t scrub_pause_wait; 1114 struct rw_semaphore scrub_super_lock; 1115 int scrub_workers_refcnt; 1116 struct btrfs_workers scrub_workers; 1117 1118 /* filesystem state */ 1119 u64 fs_state; 1120 1121 struct btrfs_delayed_root *delayed_root; 1122 }; 1123 1124 /* 1125 * in ram representation of the tree. extent_root is used for all allocations 1126 * and for the extent tree extent_root root. 1127 */ 1128 struct btrfs_root { 1129 struct extent_buffer *node; 1130 1131 struct extent_buffer *commit_root; 1132 struct btrfs_root *log_root; 1133 struct btrfs_root *reloc_root; 1134 1135 struct btrfs_root_item root_item; 1136 struct btrfs_key root_key; 1137 struct btrfs_fs_info *fs_info; 1138 struct extent_io_tree dirty_log_pages; 1139 1140 struct kobject root_kobj; 1141 struct completion kobj_unregister; 1142 struct mutex objectid_mutex; 1143 1144 spinlock_t accounting_lock; 1145 struct btrfs_block_rsv *block_rsv; 1146 1147 /* free ino cache stuff */ 1148 struct mutex fs_commit_mutex; 1149 struct btrfs_free_space_ctl *free_ino_ctl; 1150 enum btrfs_caching_type cached; 1151 spinlock_t cache_lock; 1152 wait_queue_head_t cache_wait; 1153 struct btrfs_free_space_ctl *free_ino_pinned; 1154 u64 cache_progress; 1155 struct inode *cache_inode; 1156 1157 struct mutex log_mutex; 1158 wait_queue_head_t log_writer_wait; 1159 wait_queue_head_t log_commit_wait[2]; 1160 atomic_t log_writers; 1161 atomic_t log_commit[2]; 1162 unsigned long log_transid; 1163 unsigned long last_log_commit; 1164 unsigned long log_batch; 1165 pid_t log_start_pid; 1166 bool log_multiple_pids; 1167 1168 u64 objectid; 1169 u64 last_trans; 1170 1171 /* data allocations are done in sectorsize units */ 1172 u32 sectorsize; 1173 1174 /* node allocations are done in nodesize units */ 1175 u32 nodesize; 1176 1177 /* leaf allocations are done in leafsize units */ 1178 u32 leafsize; 1179 1180 u32 stripesize; 1181 1182 u32 type; 1183 1184 u64 highest_objectid; 1185 1186 /* btrfs_record_root_in_trans is a multi-step process, 1187 * and it can race with the balancing code. But the 1188 * race is very small, and only the first time the root 1189 * is added to each transaction. So in_trans_setup 1190 * is used to tell us when more checks are required 1191 */ 1192 unsigned long in_trans_setup; 1193 int ref_cows; 1194 int track_dirty; 1195 int in_radix; 1196 1197 u64 defrag_trans_start; 1198 struct btrfs_key defrag_progress; 1199 struct btrfs_key defrag_max; 1200 int defrag_running; 1201 char *name; 1202 1203 /* the dirty list is only used by non-reference counted roots */ 1204 struct list_head dirty_list; 1205 1206 struct list_head root_list; 1207 1208 spinlock_t orphan_lock; 1209 struct list_head orphan_list; 1210 struct btrfs_block_rsv *orphan_block_rsv; 1211 int orphan_item_inserted; 1212 int orphan_cleanup_state; 1213 1214 spinlock_t inode_lock; 1215 /* red-black tree that keeps track of in-memory inodes */ 1216 struct rb_root inode_tree; 1217 1218 /* 1219 * radix tree that keeps track of delayed nodes of every inode, 1220 * protected by inode_lock 1221 */ 1222 struct radix_tree_root delayed_nodes_tree; 1223 /* 1224 * right now this just gets used so that a root has its own devid 1225 * for stat. It may be used for more later 1226 */ 1227 dev_t anon_dev; 1228 }; 1229 1230 struct btrfs_ioctl_defrag_range_args { 1231 /* start of the defrag operation */ 1232 __u64 start; 1233 1234 /* number of bytes to defrag, use (u64)-1 to say all */ 1235 __u64 len; 1236 1237 /* 1238 * flags for the operation, which can include turning 1239 * on compression for this one defrag 1240 */ 1241 __u64 flags; 1242 1243 /* 1244 * any extent bigger than this will be considered 1245 * already defragged. Use 0 to take the kernel default 1246 * Use 1 to say every single extent must be rewritten 1247 */ 1248 __u32 extent_thresh; 1249 1250 /* 1251 * which compression method to use if turning on compression 1252 * for this defrag operation. If unspecified, zlib will 1253 * be used 1254 */ 1255 __u32 compress_type; 1256 1257 /* spare for later */ 1258 __u32 unused[4]; 1259 }; 1260 1261 1262 /* 1263 * inode items have the data typically returned from stat and store other 1264 * info about object characteristics. There is one for every file and dir in 1265 * the FS 1266 */ 1267 #define BTRFS_INODE_ITEM_KEY 1 1268 #define BTRFS_INODE_REF_KEY 12 1269 #define BTRFS_XATTR_ITEM_KEY 24 1270 #define BTRFS_ORPHAN_ITEM_KEY 48 1271 /* reserve 2-15 close to the inode for later flexibility */ 1272 1273 /* 1274 * dir items are the name -> inode pointers in a directory. There is one 1275 * for every name in a directory. 1276 */ 1277 #define BTRFS_DIR_LOG_ITEM_KEY 60 1278 #define BTRFS_DIR_LOG_INDEX_KEY 72 1279 #define BTRFS_DIR_ITEM_KEY 84 1280 #define BTRFS_DIR_INDEX_KEY 96 1281 /* 1282 * extent data is for file data 1283 */ 1284 #define BTRFS_EXTENT_DATA_KEY 108 1285 1286 /* 1287 * extent csums are stored in a separate tree and hold csums for 1288 * an entire extent on disk. 1289 */ 1290 #define BTRFS_EXTENT_CSUM_KEY 128 1291 1292 /* 1293 * root items point to tree roots. They are typically in the root 1294 * tree used by the super block to find all the other trees 1295 */ 1296 #define BTRFS_ROOT_ITEM_KEY 132 1297 1298 /* 1299 * root backrefs tie subvols and snapshots to the directory entries that 1300 * reference them 1301 */ 1302 #define BTRFS_ROOT_BACKREF_KEY 144 1303 1304 /* 1305 * root refs make a fast index for listing all of the snapshots and 1306 * subvolumes referenced by a given root. They point directly to the 1307 * directory item in the root that references the subvol 1308 */ 1309 #define BTRFS_ROOT_REF_KEY 156 1310 1311 /* 1312 * extent items are in the extent map tree. These record which blocks 1313 * are used, and how many references there are to each block 1314 */ 1315 #define BTRFS_EXTENT_ITEM_KEY 168 1316 1317 #define BTRFS_TREE_BLOCK_REF_KEY 176 1318 1319 #define BTRFS_EXTENT_DATA_REF_KEY 178 1320 1321 #define BTRFS_EXTENT_REF_V0_KEY 180 1322 1323 #define BTRFS_SHARED_BLOCK_REF_KEY 182 1324 1325 #define BTRFS_SHARED_DATA_REF_KEY 184 1326 1327 /* 1328 * block groups give us hints into the extent allocation trees. Which 1329 * blocks are free etc etc 1330 */ 1331 #define BTRFS_BLOCK_GROUP_ITEM_KEY 192 1332 1333 #define BTRFS_DEV_EXTENT_KEY 204 1334 #define BTRFS_DEV_ITEM_KEY 216 1335 #define BTRFS_CHUNK_ITEM_KEY 228 1336 1337 /* 1338 * string items are for debugging. They just store a short string of 1339 * data in the FS 1340 */ 1341 #define BTRFS_STRING_ITEM_KEY 253 1342 1343 /* 1344 * Flags for mount options. 1345 * 1346 * Note: don't forget to add new options to btrfs_show_options() 1347 */ 1348 #define BTRFS_MOUNT_NODATASUM (1 << 0) 1349 #define BTRFS_MOUNT_NODATACOW (1 << 1) 1350 #define BTRFS_MOUNT_NOBARRIER (1 << 2) 1351 #define BTRFS_MOUNT_SSD (1 << 3) 1352 #define BTRFS_MOUNT_DEGRADED (1 << 4) 1353 #define BTRFS_MOUNT_COMPRESS (1 << 5) 1354 #define BTRFS_MOUNT_NOTREELOG (1 << 6) 1355 #define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7) 1356 #define BTRFS_MOUNT_SSD_SPREAD (1 << 8) 1357 #define BTRFS_MOUNT_NOSSD (1 << 9) 1358 #define BTRFS_MOUNT_DISCARD (1 << 10) 1359 #define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11) 1360 #define BTRFS_MOUNT_SPACE_CACHE (1 << 12) 1361 #define BTRFS_MOUNT_CLEAR_CACHE (1 << 13) 1362 #define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14) 1363 #define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15) 1364 #define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16) 1365 #define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17) 1366 1367 #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) 1368 #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) 1369 #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \ 1370 BTRFS_MOUNT_##opt) 1371 /* 1372 * Inode flags 1373 */ 1374 #define BTRFS_INODE_NODATASUM (1 << 0) 1375 #define BTRFS_INODE_NODATACOW (1 << 1) 1376 #define BTRFS_INODE_READONLY (1 << 2) 1377 #define BTRFS_INODE_NOCOMPRESS (1 << 3) 1378 #define BTRFS_INODE_PREALLOC (1 << 4) 1379 #define BTRFS_INODE_SYNC (1 << 5) 1380 #define BTRFS_INODE_IMMUTABLE (1 << 6) 1381 #define BTRFS_INODE_APPEND (1 << 7) 1382 #define BTRFS_INODE_NODUMP (1 << 8) 1383 #define BTRFS_INODE_NOATIME (1 << 9) 1384 #define BTRFS_INODE_DIRSYNC (1 << 10) 1385 #define BTRFS_INODE_COMPRESS (1 << 11) 1386 1387 #define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31) 1388 1389 /* some macros to generate set/get funcs for the struct fields. This 1390 * assumes there is a lefoo_to_cpu for every type, so lets make a simple 1391 * one for u8: 1392 */ 1393 #define le8_to_cpu(v) (v) 1394 #define cpu_to_le8(v) (v) 1395 #define __le8 u8 1396 1397 #define read_eb_member(eb, ptr, type, member, result) ( \ 1398 read_extent_buffer(eb, (char *)(result), \ 1399 ((unsigned long)(ptr)) + \ 1400 offsetof(type, member), \ 1401 sizeof(((type *)0)->member))) 1402 1403 #define write_eb_member(eb, ptr, type, member, result) ( \ 1404 write_extent_buffer(eb, (char *)(result), \ 1405 ((unsigned long)(ptr)) + \ 1406 offsetof(type, member), \ 1407 sizeof(((type *)0)->member))) 1408 1409 #ifndef BTRFS_SETGET_FUNCS 1410 #define BTRFS_SETGET_FUNCS(name, type, member, bits) \ 1411 u##bits btrfs_##name(struct extent_buffer *eb, type *s); \ 1412 void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val); 1413 #endif 1414 1415 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \ 1416 static inline u##bits btrfs_##name(struct extent_buffer *eb) \ 1417 { \ 1418 type *p = kmap_atomic(eb->first_page, KM_USER0); \ 1419 u##bits res = le##bits##_to_cpu(p->member); \ 1420 kunmap_atomic(p, KM_USER0); \ 1421 return res; \ 1422 } \ 1423 static inline void btrfs_set_##name(struct extent_buffer *eb, \ 1424 u##bits val) \ 1425 { \ 1426 type *p = kmap_atomic(eb->first_page, KM_USER0); \ 1427 p->member = cpu_to_le##bits(val); \ 1428 kunmap_atomic(p, KM_USER0); \ 1429 } 1430 1431 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \ 1432 static inline u##bits btrfs_##name(type *s) \ 1433 { \ 1434 return le##bits##_to_cpu(s->member); \ 1435 } \ 1436 static inline void btrfs_set_##name(type *s, u##bits val) \ 1437 { \ 1438 s->member = cpu_to_le##bits(val); \ 1439 } 1440 1441 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64); 1442 BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64); 1443 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64); 1444 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32); 1445 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32); 1446 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item, 1447 start_offset, 64); 1448 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32); 1449 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64); 1450 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32); 1451 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8); 1452 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8); 1453 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64); 1454 1455 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64); 1456 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item, 1457 total_bytes, 64); 1458 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item, 1459 bytes_used, 64); 1460 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item, 1461 io_align, 32); 1462 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item, 1463 io_width, 32); 1464 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item, 1465 sector_size, 32); 1466 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64); 1467 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item, 1468 dev_group, 32); 1469 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item, 1470 seek_speed, 8); 1471 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item, 1472 bandwidth, 8); 1473 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item, 1474 generation, 64); 1475 1476 static inline char *btrfs_device_uuid(struct btrfs_dev_item *d) 1477 { 1478 return (char *)d + offsetof(struct btrfs_dev_item, uuid); 1479 } 1480 1481 static inline char *btrfs_device_fsid(struct btrfs_dev_item *d) 1482 { 1483 return (char *)d + offsetof(struct btrfs_dev_item, fsid); 1484 } 1485 1486 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64); 1487 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64); 1488 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64); 1489 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32); 1490 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32); 1491 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32); 1492 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64); 1493 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16); 1494 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16); 1495 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64); 1496 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64); 1497 1498 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s) 1499 { 1500 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid); 1501 } 1502 1503 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64); 1504 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64); 1505 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk, 1506 stripe_len, 64); 1507 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk, 1508 io_align, 32); 1509 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk, 1510 io_width, 32); 1511 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk, 1512 sector_size, 32); 1513 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64); 1514 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk, 1515 num_stripes, 16); 1516 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk, 1517 sub_stripes, 16); 1518 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64); 1519 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64); 1520 1521 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c, 1522 int nr) 1523 { 1524 unsigned long offset = (unsigned long)c; 1525 offset += offsetof(struct btrfs_chunk, stripe); 1526 offset += nr * sizeof(struct btrfs_stripe); 1527 return (struct btrfs_stripe *)offset; 1528 } 1529 1530 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr) 1531 { 1532 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr)); 1533 } 1534 1535 static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb, 1536 struct btrfs_chunk *c, int nr) 1537 { 1538 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr)); 1539 } 1540 1541 static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb, 1542 struct btrfs_chunk *c, int nr) 1543 { 1544 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr)); 1545 } 1546 1547 /* struct btrfs_block_group_item */ 1548 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item, 1549 used, 64); 1550 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item, 1551 used, 64); 1552 BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid, 1553 struct btrfs_block_group_item, chunk_objectid, 64); 1554 1555 BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid, 1556 struct btrfs_block_group_item, chunk_objectid, 64); 1557 BTRFS_SETGET_FUNCS(disk_block_group_flags, 1558 struct btrfs_block_group_item, flags, 64); 1559 BTRFS_SETGET_STACK_FUNCS(block_group_flags, 1560 struct btrfs_block_group_item, flags, 64); 1561 1562 /* struct btrfs_inode_ref */ 1563 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); 1564 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64); 1565 1566 /* struct btrfs_inode_item */ 1567 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64); 1568 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64); 1569 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64); 1570 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64); 1571 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64); 1572 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64); 1573 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32); 1574 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32); 1575 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32); 1576 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32); 1577 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64); 1578 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64); 1579 1580 static inline struct btrfs_timespec * 1581 btrfs_inode_atime(struct btrfs_inode_item *inode_item) 1582 { 1583 unsigned long ptr = (unsigned long)inode_item; 1584 ptr += offsetof(struct btrfs_inode_item, atime); 1585 return (struct btrfs_timespec *)ptr; 1586 } 1587 1588 static inline struct btrfs_timespec * 1589 btrfs_inode_mtime(struct btrfs_inode_item *inode_item) 1590 { 1591 unsigned long ptr = (unsigned long)inode_item; 1592 ptr += offsetof(struct btrfs_inode_item, mtime); 1593 return (struct btrfs_timespec *)ptr; 1594 } 1595 1596 static inline struct btrfs_timespec * 1597 btrfs_inode_ctime(struct btrfs_inode_item *inode_item) 1598 { 1599 unsigned long ptr = (unsigned long)inode_item; 1600 ptr += offsetof(struct btrfs_inode_item, ctime); 1601 return (struct btrfs_timespec *)ptr; 1602 } 1603 1604 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64); 1605 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32); 1606 1607 /* struct btrfs_dev_extent */ 1608 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent, 1609 chunk_tree, 64); 1610 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent, 1611 chunk_objectid, 64); 1612 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent, 1613 chunk_offset, 64); 1614 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64); 1615 1616 static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev) 1617 { 1618 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid); 1619 return (u8 *)((unsigned long)dev + ptr); 1620 } 1621 1622 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64); 1623 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item, 1624 generation, 64); 1625 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64); 1626 1627 BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32); 1628 1629 1630 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8); 1631 1632 static inline void btrfs_tree_block_key(struct extent_buffer *eb, 1633 struct btrfs_tree_block_info *item, 1634 struct btrfs_disk_key *key) 1635 { 1636 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key); 1637 } 1638 1639 static inline void btrfs_set_tree_block_key(struct extent_buffer *eb, 1640 struct btrfs_tree_block_info *item, 1641 struct btrfs_disk_key *key) 1642 { 1643 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key); 1644 } 1645 1646 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref, 1647 root, 64); 1648 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref, 1649 objectid, 64); 1650 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref, 1651 offset, 64); 1652 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref, 1653 count, 32); 1654 1655 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref, 1656 count, 32); 1657 1658 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref, 1659 type, 8); 1660 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref, 1661 offset, 64); 1662 1663 static inline u32 btrfs_extent_inline_ref_size(int type) 1664 { 1665 if (type == BTRFS_TREE_BLOCK_REF_KEY || 1666 type == BTRFS_SHARED_BLOCK_REF_KEY) 1667 return sizeof(struct btrfs_extent_inline_ref); 1668 if (type == BTRFS_SHARED_DATA_REF_KEY) 1669 return sizeof(struct btrfs_shared_data_ref) + 1670 sizeof(struct btrfs_extent_inline_ref); 1671 if (type == BTRFS_EXTENT_DATA_REF_KEY) 1672 return sizeof(struct btrfs_extent_data_ref) + 1673 offsetof(struct btrfs_extent_inline_ref, offset); 1674 BUG(); 1675 return 0; 1676 } 1677 1678 BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64); 1679 BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0, 1680 generation, 64); 1681 BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64); 1682 BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32); 1683 1684 /* struct btrfs_node */ 1685 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); 1686 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); 1687 1688 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) 1689 { 1690 unsigned long ptr; 1691 ptr = offsetof(struct btrfs_node, ptrs) + 1692 sizeof(struct btrfs_key_ptr) * nr; 1693 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr); 1694 } 1695 1696 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, 1697 int nr, u64 val) 1698 { 1699 unsigned long ptr; 1700 ptr = offsetof(struct btrfs_node, ptrs) + 1701 sizeof(struct btrfs_key_ptr) * nr; 1702 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val); 1703 } 1704 1705 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) 1706 { 1707 unsigned long ptr; 1708 ptr = offsetof(struct btrfs_node, ptrs) + 1709 sizeof(struct btrfs_key_ptr) * nr; 1710 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr); 1711 } 1712 1713 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, 1714 int nr, u64 val) 1715 { 1716 unsigned long ptr; 1717 ptr = offsetof(struct btrfs_node, ptrs) + 1718 sizeof(struct btrfs_key_ptr) * nr; 1719 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val); 1720 } 1721 1722 static inline unsigned long btrfs_node_key_ptr_offset(int nr) 1723 { 1724 return offsetof(struct btrfs_node, ptrs) + 1725 sizeof(struct btrfs_key_ptr) * nr; 1726 } 1727 1728 void btrfs_node_key(struct extent_buffer *eb, 1729 struct btrfs_disk_key *disk_key, int nr); 1730 1731 static inline void btrfs_set_node_key(struct extent_buffer *eb, 1732 struct btrfs_disk_key *disk_key, int nr) 1733 { 1734 unsigned long ptr; 1735 ptr = btrfs_node_key_ptr_offset(nr); 1736 write_eb_member(eb, (struct btrfs_key_ptr *)ptr, 1737 struct btrfs_key_ptr, key, disk_key); 1738 } 1739 1740 /* struct btrfs_item */ 1741 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32); 1742 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32); 1743 1744 static inline unsigned long btrfs_item_nr_offset(int nr) 1745 { 1746 return offsetof(struct btrfs_leaf, items) + 1747 sizeof(struct btrfs_item) * nr; 1748 } 1749 1750 static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb, 1751 int nr) 1752 { 1753 return (struct btrfs_item *)btrfs_item_nr_offset(nr); 1754 } 1755 1756 static inline u32 btrfs_item_end(struct extent_buffer *eb, 1757 struct btrfs_item *item) 1758 { 1759 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item); 1760 } 1761 1762 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) 1763 { 1764 return btrfs_item_end(eb, btrfs_item_nr(eb, nr)); 1765 } 1766 1767 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr) 1768 { 1769 return btrfs_item_offset(eb, btrfs_item_nr(eb, nr)); 1770 } 1771 1772 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) 1773 { 1774 return btrfs_item_size(eb, btrfs_item_nr(eb, nr)); 1775 } 1776 1777 static inline void btrfs_item_key(struct extent_buffer *eb, 1778 struct btrfs_disk_key *disk_key, int nr) 1779 { 1780 struct btrfs_item *item = btrfs_item_nr(eb, nr); 1781 read_eb_member(eb, item, struct btrfs_item, key, disk_key); 1782 } 1783 1784 static inline void btrfs_set_item_key(struct extent_buffer *eb, 1785 struct btrfs_disk_key *disk_key, int nr) 1786 { 1787 struct btrfs_item *item = btrfs_item_nr(eb, nr); 1788 write_eb_member(eb, item, struct btrfs_item, key, disk_key); 1789 } 1790 1791 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64); 1792 1793 /* 1794 * struct btrfs_root_ref 1795 */ 1796 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64); 1797 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64); 1798 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16); 1799 1800 /* struct btrfs_dir_item */ 1801 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16); 1802 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8); 1803 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16); 1804 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64); 1805 1806 static inline void btrfs_dir_item_key(struct extent_buffer *eb, 1807 struct btrfs_dir_item *item, 1808 struct btrfs_disk_key *key) 1809 { 1810 read_eb_member(eb, item, struct btrfs_dir_item, location, key); 1811 } 1812 1813 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb, 1814 struct btrfs_dir_item *item, 1815 struct btrfs_disk_key *key) 1816 { 1817 write_eb_member(eb, item, struct btrfs_dir_item, location, key); 1818 } 1819 1820 BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header, 1821 num_entries, 64); 1822 BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header, 1823 num_bitmaps, 64); 1824 BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header, 1825 generation, 64); 1826 1827 static inline void btrfs_free_space_key(struct extent_buffer *eb, 1828 struct btrfs_free_space_header *h, 1829 struct btrfs_disk_key *key) 1830 { 1831 read_eb_member(eb, h, struct btrfs_free_space_header, location, key); 1832 } 1833 1834 static inline void btrfs_set_free_space_key(struct extent_buffer *eb, 1835 struct btrfs_free_space_header *h, 1836 struct btrfs_disk_key *key) 1837 { 1838 write_eb_member(eb, h, struct btrfs_free_space_header, location, key); 1839 } 1840 1841 /* struct btrfs_disk_key */ 1842 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key, 1843 objectid, 64); 1844 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64); 1845 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8); 1846 1847 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu, 1848 struct btrfs_disk_key *disk) 1849 { 1850 cpu->offset = le64_to_cpu(disk->offset); 1851 cpu->type = disk->type; 1852 cpu->objectid = le64_to_cpu(disk->objectid); 1853 } 1854 1855 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk, 1856 struct btrfs_key *cpu) 1857 { 1858 disk->offset = cpu_to_le64(cpu->offset); 1859 disk->type = cpu->type; 1860 disk->objectid = cpu_to_le64(cpu->objectid); 1861 } 1862 1863 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb, 1864 struct btrfs_key *key, int nr) 1865 { 1866 struct btrfs_disk_key disk_key; 1867 btrfs_node_key(eb, &disk_key, nr); 1868 btrfs_disk_key_to_cpu(key, &disk_key); 1869 } 1870 1871 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb, 1872 struct btrfs_key *key, int nr) 1873 { 1874 struct btrfs_disk_key disk_key; 1875 btrfs_item_key(eb, &disk_key, nr); 1876 btrfs_disk_key_to_cpu(key, &disk_key); 1877 } 1878 1879 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb, 1880 struct btrfs_dir_item *item, 1881 struct btrfs_key *key) 1882 { 1883 struct btrfs_disk_key disk_key; 1884 btrfs_dir_item_key(eb, item, &disk_key); 1885 btrfs_disk_key_to_cpu(key, &disk_key); 1886 } 1887 1888 1889 static inline u8 btrfs_key_type(struct btrfs_key *key) 1890 { 1891 return key->type; 1892 } 1893 1894 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val) 1895 { 1896 key->type = val; 1897 } 1898 1899 /* struct btrfs_header */ 1900 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64); 1901 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header, 1902 generation, 64); 1903 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64); 1904 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32); 1905 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64); 1906 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8); 1907 1908 static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag) 1909 { 1910 return (btrfs_header_flags(eb) & flag) == flag; 1911 } 1912 1913 static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag) 1914 { 1915 u64 flags = btrfs_header_flags(eb); 1916 btrfs_set_header_flags(eb, flags | flag); 1917 return (flags & flag) == flag; 1918 } 1919 1920 static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag) 1921 { 1922 u64 flags = btrfs_header_flags(eb); 1923 btrfs_set_header_flags(eb, flags & ~flag); 1924 return (flags & flag) == flag; 1925 } 1926 1927 static inline int btrfs_header_backref_rev(struct extent_buffer *eb) 1928 { 1929 u64 flags = btrfs_header_flags(eb); 1930 return flags >> BTRFS_BACKREF_REV_SHIFT; 1931 } 1932 1933 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb, 1934 int rev) 1935 { 1936 u64 flags = btrfs_header_flags(eb); 1937 flags &= ~BTRFS_BACKREF_REV_MASK; 1938 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT; 1939 btrfs_set_header_flags(eb, flags); 1940 } 1941 1942 static inline u8 *btrfs_header_fsid(struct extent_buffer *eb) 1943 { 1944 unsigned long ptr = offsetof(struct btrfs_header, fsid); 1945 return (u8 *)ptr; 1946 } 1947 1948 static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb) 1949 { 1950 unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid); 1951 return (u8 *)ptr; 1952 } 1953 1954 static inline int btrfs_is_leaf(struct extent_buffer *eb) 1955 { 1956 return btrfs_header_level(eb) == 0; 1957 } 1958 1959 /* struct btrfs_root_item */ 1960 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item, 1961 generation, 64); 1962 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32); 1963 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64); 1964 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8); 1965 1966 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item, 1967 generation, 64); 1968 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64); 1969 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8); 1970 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64); 1971 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32); 1972 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64); 1973 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64); 1974 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64); 1975 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item, 1976 last_snapshot, 64); 1977 1978 static inline bool btrfs_root_readonly(struct btrfs_root *root) 1979 { 1980 return root->root_item.flags & BTRFS_ROOT_SUBVOL_RDONLY; 1981 } 1982 1983 /* struct btrfs_super_block */ 1984 1985 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64); 1986 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64); 1987 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block, 1988 generation, 64); 1989 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64); 1990 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size, 1991 struct btrfs_super_block, sys_chunk_array_size, 32); 1992 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation, 1993 struct btrfs_super_block, chunk_root_generation, 64); 1994 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block, 1995 root_level, 8); 1996 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block, 1997 chunk_root, 64); 1998 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block, 1999 chunk_root_level, 8); 2000 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block, 2001 log_root, 64); 2002 BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block, 2003 log_root_transid, 64); 2004 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block, 2005 log_root_level, 8); 2006 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block, 2007 total_bytes, 64); 2008 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block, 2009 bytes_used, 64); 2010 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block, 2011 sectorsize, 32); 2012 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block, 2013 nodesize, 32); 2014 BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block, 2015 leafsize, 32); 2016 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block, 2017 stripesize, 32); 2018 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block, 2019 root_dir_objectid, 64); 2020 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block, 2021 num_devices, 64); 2022 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block, 2023 compat_flags, 64); 2024 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block, 2025 compat_ro_flags, 64); 2026 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block, 2027 incompat_flags, 64); 2028 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block, 2029 csum_type, 16); 2030 BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block, 2031 cache_generation, 64); 2032 2033 static inline int btrfs_super_csum_size(struct btrfs_super_block *s) 2034 { 2035 int t = btrfs_super_csum_type(s); 2036 BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes)); 2037 return btrfs_csum_sizes[t]; 2038 } 2039 2040 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) 2041 { 2042 return offsetof(struct btrfs_leaf, items); 2043 } 2044 2045 /* struct btrfs_file_extent_item */ 2046 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8); 2047 2048 static inline unsigned long 2049 btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e) 2050 { 2051 unsigned long offset = (unsigned long)e; 2052 offset += offsetof(struct btrfs_file_extent_item, disk_bytenr); 2053 return offset; 2054 } 2055 2056 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize) 2057 { 2058 return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize; 2059 } 2060 2061 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item, 2062 disk_bytenr, 64); 2063 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item, 2064 generation, 64); 2065 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item, 2066 disk_num_bytes, 64); 2067 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item, 2068 offset, 64); 2069 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item, 2070 num_bytes, 64); 2071 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item, 2072 ram_bytes, 64); 2073 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item, 2074 compression, 8); 2075 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item, 2076 encryption, 8); 2077 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item, 2078 other_encoding, 16); 2079 2080 /* this returns the number of file bytes represented by the inline item. 2081 * If an item is compressed, this is the uncompressed size 2082 */ 2083 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb, 2084 struct btrfs_file_extent_item *e) 2085 { 2086 return btrfs_file_extent_ram_bytes(eb, e); 2087 } 2088 2089 /* 2090 * this returns the number of bytes used by the item on disk, minus the 2091 * size of any extent headers. If a file is compressed on disk, this is 2092 * the compressed size 2093 */ 2094 static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb, 2095 struct btrfs_item *e) 2096 { 2097 unsigned long offset; 2098 offset = offsetof(struct btrfs_file_extent_item, disk_bytenr); 2099 return btrfs_item_size(eb, e) - offset; 2100 } 2101 2102 static inline struct btrfs_root *btrfs_sb(struct super_block *sb) 2103 { 2104 return sb->s_fs_info; 2105 } 2106 2107 static inline u32 btrfs_level_size(struct btrfs_root *root, int level) 2108 { 2109 if (level == 0) 2110 return root->leafsize; 2111 return root->nodesize; 2112 } 2113 2114 /* helper function to cast into the data area of the leaf. */ 2115 #define btrfs_item_ptr(leaf, slot, type) \ 2116 ((type *)(btrfs_leaf_data(leaf) + \ 2117 btrfs_item_offset_nr(leaf, slot))) 2118 2119 #define btrfs_item_ptr_offset(leaf, slot) \ 2120 ((unsigned long)(btrfs_leaf_data(leaf) + \ 2121 btrfs_item_offset_nr(leaf, slot))) 2122 2123 static inline struct dentry *fdentry(struct file *file) 2124 { 2125 return file->f_path.dentry; 2126 } 2127 2128 static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info) 2129 { 2130 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) && 2131 (space_info->flags & BTRFS_BLOCK_GROUP_DATA)); 2132 } 2133 2134 /* extent-tree.c */ 2135 static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root, 2136 unsigned num_items) 2137 { 2138 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) * 2139 3 * num_items; 2140 } 2141 2142 void btrfs_put_block_group(struct btrfs_block_group_cache *cache); 2143 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, 2144 struct btrfs_root *root, unsigned long count); 2145 int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len); 2146 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans, 2147 struct btrfs_root *root, u64 bytenr, 2148 u64 num_bytes, u64 *refs, u64 *flags); 2149 int btrfs_pin_extent(struct btrfs_root *root, 2150 u64 bytenr, u64 num, int reserved); 2151 int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans, 2152 struct btrfs_root *root, 2153 u64 objectid, u64 offset, u64 bytenr); 2154 struct btrfs_block_group_cache *btrfs_lookup_block_group( 2155 struct btrfs_fs_info *info, 2156 u64 bytenr); 2157 void btrfs_put_block_group(struct btrfs_block_group_cache *cache); 2158 u64 btrfs_find_block_group(struct btrfs_root *root, 2159 u64 search_start, u64 search_hint, int owner); 2160 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 2161 struct btrfs_root *root, u32 blocksize, 2162 u64 parent, u64 root_objectid, 2163 struct btrfs_disk_key *key, int level, 2164 u64 hint, u64 empty_size); 2165 void btrfs_free_tree_block(struct btrfs_trans_handle *trans, 2166 struct btrfs_root *root, 2167 struct extent_buffer *buf, 2168 u64 parent, int last_ref); 2169 struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans, 2170 struct btrfs_root *root, 2171 u64 bytenr, u32 blocksize, 2172 int level); 2173 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans, 2174 struct btrfs_root *root, 2175 u64 root_objectid, u64 owner, 2176 u64 offset, struct btrfs_key *ins); 2177 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans, 2178 struct btrfs_root *root, 2179 u64 root_objectid, u64 owner, u64 offset, 2180 struct btrfs_key *ins); 2181 int btrfs_reserve_extent(struct btrfs_trans_handle *trans, 2182 struct btrfs_root *root, 2183 u64 num_bytes, u64 min_alloc_size, 2184 u64 empty_size, u64 hint_byte, 2185 u64 search_end, struct btrfs_key *ins, 2186 u64 data); 2187 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 2188 struct extent_buffer *buf, int full_backref); 2189 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 2190 struct extent_buffer *buf, int full_backref); 2191 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans, 2192 struct btrfs_root *root, 2193 u64 bytenr, u64 num_bytes, u64 flags, 2194 int is_data); 2195 int btrfs_free_extent(struct btrfs_trans_handle *trans, 2196 struct btrfs_root *root, 2197 u64 bytenr, u64 num_bytes, u64 parent, 2198 u64 root_objectid, u64 owner, u64 offset); 2199 2200 int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len); 2201 int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache, 2202 u64 num_bytes, int reserve, int sinfo); 2203 int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, 2204 struct btrfs_root *root); 2205 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, 2206 struct btrfs_root *root); 2207 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, 2208 struct btrfs_root *root, 2209 u64 bytenr, u64 num_bytes, u64 parent, 2210 u64 root_objectid, u64 owner, u64 offset); 2211 2212 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 2213 struct btrfs_root *root); 2214 int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr); 2215 int btrfs_free_block_groups(struct btrfs_fs_info *info); 2216 int btrfs_read_block_groups(struct btrfs_root *root); 2217 int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr); 2218 int btrfs_make_block_group(struct btrfs_trans_handle *trans, 2219 struct btrfs_root *root, u64 bytes_used, 2220 u64 type, u64 chunk_objectid, u64 chunk_offset, 2221 u64 size); 2222 int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 2223 struct btrfs_root *root, u64 group_start); 2224 u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags); 2225 u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data); 2226 void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde); 2227 void btrfs_clear_space_info_full(struct btrfs_fs_info *info); 2228 int btrfs_check_data_free_space(struct inode *inode, u64 bytes); 2229 void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes); 2230 void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans, 2231 struct btrfs_root *root); 2232 int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, 2233 struct inode *inode); 2234 void btrfs_orphan_release_metadata(struct inode *inode); 2235 int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans, 2236 struct btrfs_pending_snapshot *pending); 2237 int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes); 2238 void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes); 2239 int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes); 2240 void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes); 2241 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv); 2242 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root); 2243 void btrfs_free_block_rsv(struct btrfs_root *root, 2244 struct btrfs_block_rsv *rsv); 2245 void btrfs_add_durable_block_rsv(struct btrfs_fs_info *fs_info, 2246 struct btrfs_block_rsv *rsv); 2247 int btrfs_block_rsv_add(struct btrfs_trans_handle *trans, 2248 struct btrfs_root *root, 2249 struct btrfs_block_rsv *block_rsv, 2250 u64 num_bytes); 2251 int btrfs_block_rsv_check(struct btrfs_trans_handle *trans, 2252 struct btrfs_root *root, 2253 struct btrfs_block_rsv *block_rsv, 2254 u64 min_reserved, int min_factor); 2255 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv, 2256 struct btrfs_block_rsv *dst_rsv, 2257 u64 num_bytes); 2258 void btrfs_block_rsv_release(struct btrfs_root *root, 2259 struct btrfs_block_rsv *block_rsv, 2260 u64 num_bytes); 2261 int btrfs_truncate_reserve_metadata(struct btrfs_trans_handle *trans, 2262 struct btrfs_root *root, 2263 struct btrfs_block_rsv *rsv); 2264 int btrfs_set_block_group_ro(struct btrfs_root *root, 2265 struct btrfs_block_group_cache *cache); 2266 int btrfs_set_block_group_rw(struct btrfs_root *root, 2267 struct btrfs_block_group_cache *cache); 2268 void btrfs_put_block_group_cache(struct btrfs_fs_info *info); 2269 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo); 2270 int btrfs_error_unpin_extent_range(struct btrfs_root *root, 2271 u64 start, u64 end); 2272 int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr, 2273 u64 num_bytes, u64 *actual_bytes); 2274 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, 2275 struct btrfs_root *root, u64 type); 2276 int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range); 2277 2278 int btrfs_init_space_info(struct btrfs_fs_info *fs_info); 2279 /* ctree.c */ 2280 int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key, 2281 int level, int *slot); 2282 int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2); 2283 int btrfs_previous_item(struct btrfs_root *root, 2284 struct btrfs_path *path, u64 min_objectid, 2285 int type); 2286 int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, 2287 struct btrfs_root *root, struct btrfs_path *path, 2288 struct btrfs_key *new_key); 2289 struct extent_buffer *btrfs_root_node(struct btrfs_root *root); 2290 struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root); 2291 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path, 2292 struct btrfs_key *key, int lowest_level, 2293 int cache_only, u64 min_trans); 2294 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 2295 struct btrfs_key *max_key, 2296 struct btrfs_path *path, int cache_only, 2297 u64 min_trans); 2298 int btrfs_cow_block(struct btrfs_trans_handle *trans, 2299 struct btrfs_root *root, struct extent_buffer *buf, 2300 struct extent_buffer *parent, int parent_slot, 2301 struct extent_buffer **cow_ret); 2302 int btrfs_copy_root(struct btrfs_trans_handle *trans, 2303 struct btrfs_root *root, 2304 struct extent_buffer *buf, 2305 struct extent_buffer **cow_ret, u64 new_root_objectid); 2306 int btrfs_block_can_be_shared(struct btrfs_root *root, 2307 struct extent_buffer *buf); 2308 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root 2309 *root, struct btrfs_path *path, u32 data_size); 2310 int btrfs_truncate_item(struct btrfs_trans_handle *trans, 2311 struct btrfs_root *root, 2312 struct btrfs_path *path, 2313 u32 new_size, int from_end); 2314 int btrfs_split_item(struct btrfs_trans_handle *trans, 2315 struct btrfs_root *root, 2316 struct btrfs_path *path, 2317 struct btrfs_key *new_key, 2318 unsigned long split_offset); 2319 int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 2320 struct btrfs_root *root, 2321 struct btrfs_path *path, 2322 struct btrfs_key *new_key); 2323 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root 2324 *root, struct btrfs_key *key, struct btrfs_path *p, int 2325 ins_len, int cow); 2326 int btrfs_realloc_node(struct btrfs_trans_handle *trans, 2327 struct btrfs_root *root, struct extent_buffer *parent, 2328 int start_slot, int cache_only, u64 *last_ret, 2329 struct btrfs_key *progress); 2330 void btrfs_release_path(struct btrfs_path *p); 2331 struct btrfs_path *btrfs_alloc_path(void); 2332 void btrfs_free_path(struct btrfs_path *p); 2333 void btrfs_set_path_blocking(struct btrfs_path *p); 2334 void btrfs_clear_path_blocking(struct btrfs_path *p, 2335 struct extent_buffer *held, int held_rw); 2336 void btrfs_unlock_up_safe(struct btrfs_path *p, int level); 2337 2338 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 2339 struct btrfs_path *path, int slot, int nr); 2340 static inline int btrfs_del_item(struct btrfs_trans_handle *trans, 2341 struct btrfs_root *root, 2342 struct btrfs_path *path) 2343 { 2344 return btrfs_del_items(trans, root, path, path->slots[0], 1); 2345 } 2346 2347 int setup_items_for_insert(struct btrfs_trans_handle *trans, 2348 struct btrfs_root *root, struct btrfs_path *path, 2349 struct btrfs_key *cpu_key, u32 *data_size, 2350 u32 total_data, u32 total_size, int nr); 2351 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root 2352 *root, struct btrfs_key *key, void *data, u32 data_size); 2353 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, 2354 struct btrfs_root *root, 2355 struct btrfs_path *path, 2356 struct btrfs_key *cpu_key, u32 *data_size, int nr); 2357 2358 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, 2359 struct btrfs_root *root, 2360 struct btrfs_path *path, 2361 struct btrfs_key *key, 2362 u32 data_size) 2363 { 2364 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1); 2365 } 2366 2367 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path); 2368 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); 2369 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); 2370 int btrfs_drop_snapshot(struct btrfs_root *root, 2371 struct btrfs_block_rsv *block_rsv, int update_ref); 2372 int btrfs_drop_subtree(struct btrfs_trans_handle *trans, 2373 struct btrfs_root *root, 2374 struct extent_buffer *node, 2375 struct extent_buffer *parent); 2376 static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info) 2377 { 2378 /* 2379 * Get synced with close_ctree() 2380 */ 2381 smp_mb(); 2382 return fs_info->closing; 2383 } 2384 2385 /* root-item.c */ 2386 int btrfs_find_root_ref(struct btrfs_root *tree_root, 2387 struct btrfs_path *path, 2388 u64 root_id, u64 ref_id); 2389 int btrfs_add_root_ref(struct btrfs_trans_handle *trans, 2390 struct btrfs_root *tree_root, 2391 u64 root_id, u64 ref_id, u64 dirid, u64 sequence, 2392 const char *name, int name_len); 2393 int btrfs_del_root_ref(struct btrfs_trans_handle *trans, 2394 struct btrfs_root *tree_root, 2395 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence, 2396 const char *name, int name_len); 2397 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, 2398 struct btrfs_key *key); 2399 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root 2400 *root, struct btrfs_key *key, struct btrfs_root_item 2401 *item); 2402 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root 2403 *root, struct btrfs_key *key, struct btrfs_root_item 2404 *item); 2405 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct 2406 btrfs_root_item *item, struct btrfs_key *key); 2407 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid); 2408 int btrfs_find_orphan_roots(struct btrfs_root *tree_root); 2409 void btrfs_set_root_node(struct btrfs_root_item *item, 2410 struct extent_buffer *node); 2411 void btrfs_check_and_init_root_item(struct btrfs_root_item *item); 2412 2413 /* dir-item.c */ 2414 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, 2415 struct btrfs_root *root, const char *name, 2416 int name_len, struct inode *dir, 2417 struct btrfs_key *location, u8 type, u64 index); 2418 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, 2419 struct btrfs_root *root, 2420 struct btrfs_path *path, u64 dir, 2421 const char *name, int name_len, 2422 int mod); 2423 struct btrfs_dir_item * 2424 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans, 2425 struct btrfs_root *root, 2426 struct btrfs_path *path, u64 dir, 2427 u64 objectid, const char *name, int name_len, 2428 int mod); 2429 struct btrfs_dir_item * 2430 btrfs_search_dir_index_item(struct btrfs_root *root, 2431 struct btrfs_path *path, u64 dirid, 2432 const char *name, int name_len); 2433 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, 2434 struct btrfs_path *path, 2435 const char *name, int name_len); 2436 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, 2437 struct btrfs_root *root, 2438 struct btrfs_path *path, 2439 struct btrfs_dir_item *di); 2440 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, 2441 struct btrfs_root *root, 2442 struct btrfs_path *path, u64 objectid, 2443 const char *name, u16 name_len, 2444 const void *data, u16 data_len); 2445 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans, 2446 struct btrfs_root *root, 2447 struct btrfs_path *path, u64 dir, 2448 const char *name, u16 name_len, 2449 int mod); 2450 int verify_dir_item(struct btrfs_root *root, 2451 struct extent_buffer *leaf, 2452 struct btrfs_dir_item *dir_item); 2453 2454 /* orphan.c */ 2455 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans, 2456 struct btrfs_root *root, u64 offset); 2457 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans, 2458 struct btrfs_root *root, u64 offset); 2459 int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset); 2460 2461 /* inode-item.c */ 2462 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, 2463 struct btrfs_root *root, 2464 const char *name, int name_len, 2465 u64 inode_objectid, u64 ref_objectid, u64 index); 2466 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 2467 struct btrfs_root *root, 2468 const char *name, int name_len, 2469 u64 inode_objectid, u64 ref_objectid, u64 *index); 2470 struct btrfs_inode_ref * 2471 btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans, 2472 struct btrfs_root *root, 2473 struct btrfs_path *path, 2474 const char *name, int name_len, 2475 u64 inode_objectid, u64 ref_objectid, int mod); 2476 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, 2477 struct btrfs_root *root, 2478 struct btrfs_path *path, u64 objectid); 2479 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root 2480 *root, struct btrfs_path *path, 2481 struct btrfs_key *location, int mod); 2482 2483 /* file-item.c */ 2484 int btrfs_del_csums(struct btrfs_trans_handle *trans, 2485 struct btrfs_root *root, u64 bytenr, u64 len); 2486 int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode, 2487 struct bio *bio, u32 *dst); 2488 int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode, 2489 struct bio *bio, u64 logical_offset, u32 *dst); 2490 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 2491 struct btrfs_root *root, 2492 u64 objectid, u64 pos, 2493 u64 disk_offset, u64 disk_num_bytes, 2494 u64 num_bytes, u64 offset, u64 ram_bytes, 2495 u8 compression, u8 encryption, u16 other_encoding); 2496 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 2497 struct btrfs_root *root, 2498 struct btrfs_path *path, u64 objectid, 2499 u64 bytenr, int mod); 2500 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, 2501 struct btrfs_root *root, 2502 struct btrfs_ordered_sum *sums); 2503 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, 2504 struct bio *bio, u64 file_start, int contig); 2505 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans, 2506 struct btrfs_root *root, 2507 struct btrfs_path *path, 2508 u64 bytenr, int cow); 2509 int btrfs_csum_truncate(struct btrfs_trans_handle *trans, 2510 struct btrfs_root *root, struct btrfs_path *path, 2511 u64 isize); 2512 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 2513 struct list_head *list, int search_commit); 2514 /* inode.c */ 2515 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page, 2516 size_t pg_offset, u64 start, u64 len, 2517 int create); 2518 2519 /* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */ 2520 #if defined(ClearPageFsMisc) && !defined(ClearPageChecked) 2521 #define ClearPageChecked ClearPageFsMisc 2522 #define SetPageChecked SetPageFsMisc 2523 #define PageChecked PageFsMisc 2524 #endif 2525 2526 /* This forces readahead on a given range of bytes in an inode */ 2527 static inline void btrfs_force_ra(struct address_space *mapping, 2528 struct file_ra_state *ra, struct file *file, 2529 pgoff_t offset, unsigned long req_size) 2530 { 2531 page_cache_sync_readahead(mapping, ra, file, offset, req_size); 2532 } 2533 2534 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry); 2535 int btrfs_set_inode_index(struct inode *dir, u64 *index); 2536 int btrfs_unlink_inode(struct btrfs_trans_handle *trans, 2537 struct btrfs_root *root, 2538 struct inode *dir, struct inode *inode, 2539 const char *name, int name_len); 2540 int btrfs_add_link(struct btrfs_trans_handle *trans, 2541 struct inode *parent_inode, struct inode *inode, 2542 const char *name, int name_len, int add_backref, u64 index); 2543 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, 2544 struct btrfs_root *root, 2545 struct inode *dir, u64 objectid, 2546 const char *name, int name_len); 2547 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, 2548 struct btrfs_root *root, 2549 struct inode *inode, u64 new_size, 2550 u32 min_type); 2551 2552 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput); 2553 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end, 2554 struct extent_state **cached_state); 2555 int btrfs_writepages(struct address_space *mapping, 2556 struct writeback_control *wbc); 2557 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans, 2558 struct btrfs_root *new_root, u64 new_dirid); 2559 int btrfs_merge_bio_hook(struct page *page, unsigned long offset, 2560 size_t size, struct bio *bio, unsigned long bio_flags); 2561 2562 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf); 2563 int btrfs_readpage(struct file *file, struct page *page); 2564 void btrfs_evict_inode(struct inode *inode); 2565 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc); 2566 void btrfs_dirty_inode(struct inode *inode, int flags); 2567 struct inode *btrfs_alloc_inode(struct super_block *sb); 2568 void btrfs_destroy_inode(struct inode *inode); 2569 int btrfs_drop_inode(struct inode *inode); 2570 int btrfs_init_cachep(void); 2571 void btrfs_destroy_cachep(void); 2572 long btrfs_ioctl_trans_end(struct file *file); 2573 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location, 2574 struct btrfs_root *root, int *was_new); 2575 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 2576 size_t pg_offset, u64 start, u64 end, 2577 int create); 2578 int btrfs_update_inode(struct btrfs_trans_handle *trans, 2579 struct btrfs_root *root, 2580 struct inode *inode); 2581 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode); 2582 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode); 2583 int btrfs_orphan_cleanup(struct btrfs_root *root); 2584 void btrfs_orphan_pre_snapshot(struct btrfs_trans_handle *trans, 2585 struct btrfs_pending_snapshot *pending, 2586 u64 *bytes_to_reserve); 2587 void btrfs_orphan_post_snapshot(struct btrfs_trans_handle *trans, 2588 struct btrfs_pending_snapshot *pending); 2589 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, 2590 struct btrfs_root *root); 2591 int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size); 2592 int btrfs_invalidate_inodes(struct btrfs_root *root); 2593 void btrfs_add_delayed_iput(struct inode *inode); 2594 void btrfs_run_delayed_iputs(struct btrfs_root *root); 2595 int btrfs_prealloc_file_range(struct inode *inode, int mode, 2596 u64 start, u64 num_bytes, u64 min_size, 2597 loff_t actual_len, u64 *alloc_hint); 2598 int btrfs_prealloc_file_range_trans(struct inode *inode, 2599 struct btrfs_trans_handle *trans, int mode, 2600 u64 start, u64 num_bytes, u64 min_size, 2601 loff_t actual_len, u64 *alloc_hint); 2602 extern const struct dentry_operations btrfs_dentry_operations; 2603 2604 /* ioctl.c */ 2605 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 2606 void btrfs_update_iflags(struct inode *inode); 2607 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir); 2608 int btrfs_defrag_file(struct inode *inode, struct file *file, 2609 struct btrfs_ioctl_defrag_range_args *range, 2610 u64 newer_than, unsigned long max_pages); 2611 /* file.c */ 2612 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans, 2613 struct inode *inode); 2614 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info); 2615 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync); 2616 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, 2617 int skip_pinned); 2618 extern const struct file_operations btrfs_file_operations; 2619 int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode, 2620 u64 start, u64 end, u64 *hint_byte, int drop_cache); 2621 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, 2622 struct inode *inode, u64 start, u64 end); 2623 int btrfs_release_file(struct inode *inode, struct file *file); 2624 void btrfs_drop_pages(struct page **pages, size_t num_pages); 2625 int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode, 2626 struct page **pages, size_t num_pages, 2627 loff_t pos, size_t write_bytes, 2628 struct extent_state **cached); 2629 2630 /* tree-defrag.c */ 2631 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, 2632 struct btrfs_root *root, int cache_only); 2633 2634 /* sysfs.c */ 2635 int btrfs_init_sysfs(void); 2636 void btrfs_exit_sysfs(void); 2637 2638 /* xattr.c */ 2639 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size); 2640 2641 /* super.c */ 2642 int btrfs_parse_options(struct btrfs_root *root, char *options); 2643 int btrfs_sync_fs(struct super_block *sb, int wait); 2644 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, 2645 unsigned int line, int errno); 2646 2647 #define btrfs_std_error(fs_info, errno) \ 2648 do { \ 2649 if ((errno)) \ 2650 __btrfs_std_error((fs_info), __func__, __LINE__, (errno));\ 2651 } while (0) 2652 2653 /* acl.c */ 2654 #ifdef CONFIG_BTRFS_FS_POSIX_ACL 2655 struct posix_acl *btrfs_get_acl(struct inode *inode, int type); 2656 int btrfs_init_acl(struct btrfs_trans_handle *trans, 2657 struct inode *inode, struct inode *dir); 2658 int btrfs_acl_chmod(struct inode *inode); 2659 #else 2660 #define btrfs_get_acl NULL 2661 static inline int btrfs_init_acl(struct btrfs_trans_handle *trans, 2662 struct inode *inode, struct inode *dir) 2663 { 2664 return 0; 2665 } 2666 static inline int btrfs_acl_chmod(struct inode *inode) 2667 { 2668 return 0; 2669 } 2670 #endif 2671 2672 /* relocation.c */ 2673 int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start); 2674 int btrfs_init_reloc_root(struct btrfs_trans_handle *trans, 2675 struct btrfs_root *root); 2676 int btrfs_update_reloc_root(struct btrfs_trans_handle *trans, 2677 struct btrfs_root *root); 2678 int btrfs_recover_relocation(struct btrfs_root *root); 2679 int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len); 2680 void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, 2681 struct btrfs_root *root, struct extent_buffer *buf, 2682 struct extent_buffer *cow); 2683 void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans, 2684 struct btrfs_pending_snapshot *pending, 2685 u64 *bytes_to_reserve); 2686 void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, 2687 struct btrfs_pending_snapshot *pending); 2688 2689 /* scrub.c */ 2690 int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, 2691 struct btrfs_scrub_progress *progress, int readonly); 2692 int btrfs_scrub_pause(struct btrfs_root *root); 2693 int btrfs_scrub_pause_super(struct btrfs_root *root); 2694 int btrfs_scrub_continue(struct btrfs_root *root); 2695 int btrfs_scrub_continue_super(struct btrfs_root *root); 2696 int btrfs_scrub_cancel(struct btrfs_root *root); 2697 int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev); 2698 int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid); 2699 int btrfs_scrub_progress(struct btrfs_root *root, u64 devid, 2700 struct btrfs_scrub_progress *progress); 2701 2702 #endif 2703