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__ 20 #define __BTRFS__ 21 22 #include <linux/version.h> 23 #include <linux/mm.h> 24 #include <linux/highmem.h> 25 #include <linux/fs.h> 26 #include <linux/workqueue.h> 27 #include <linux/completion.h> 28 #include <asm/kmap_types.h> 29 #include "bit-radix.h" 30 #include "extent_map.h" 31 32 struct btrfs_trans_handle; 33 struct btrfs_transaction; 34 extern struct kmem_cache *btrfs_trans_handle_cachep; 35 extern struct kmem_cache *btrfs_transaction_cachep; 36 extern struct kmem_cache *btrfs_bit_radix_cachep; 37 extern struct kmem_cache *btrfs_path_cachep; 38 39 #define BTRFS_MAGIC "_B2RfS_M" 40 41 #define BTRFS_MAX_LEVEL 8 42 #define BTRFS_ROOT_TREE_OBJECTID 1ULL 43 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL 44 #define BTRFS_FS_TREE_OBJECTID 3ULL 45 #define BTRFS_ROOT_TREE_DIR_OBJECTID 4ULL 46 #define BTRFS_FIRST_FREE_OBJECTID 256ULL 47 48 /* 49 * we can actually store much bigger names, but lets not confuse the rest 50 * of linux 51 */ 52 #define BTRFS_NAME_LEN 255 53 54 /* 32 bytes in various csum fields */ 55 #define BTRFS_CSUM_SIZE 32 56 /* four bytes for CRC32 */ 57 #define BTRFS_CRC32_SIZE 4 58 #define BTRFS_EMPTY_DIR_SIZE 0 59 60 #define BTRFS_FT_UNKNOWN 0 61 #define BTRFS_FT_REG_FILE 1 62 #define BTRFS_FT_DIR 2 63 #define BTRFS_FT_CHRDEV 3 64 #define BTRFS_FT_BLKDEV 4 65 #define BTRFS_FT_FIFO 5 66 #define BTRFS_FT_SOCK 6 67 #define BTRFS_FT_SYMLINK 7 68 #define BTRFS_FT_XATTR 8 69 #define BTRFS_FT_MAX 9 70 71 /* 72 * the key defines the order in the tree, and so it also defines (optimal) 73 * block layout. objectid corresonds to the inode number. The flags 74 * tells us things about the object, and is a kind of stream selector. 75 * so for a given inode, keys with flags of 1 might refer to the inode 76 * data, flags of 2 may point to file data in the btree and flags == 3 77 * may point to extents. 78 * 79 * offset is the starting byte offset for this key in the stream. 80 * 81 * btrfs_disk_key is in disk byte order. struct btrfs_key is always 82 * in cpu native order. Otherwise they are identical and their sizes 83 * should be the same (ie both packed) 84 */ 85 struct btrfs_disk_key { 86 __le64 objectid; 87 u8 type; 88 __le64 offset; 89 } __attribute__ ((__packed__)); 90 91 struct btrfs_key { 92 u64 objectid; 93 u8 type; 94 u64 offset; 95 } __attribute__ ((__packed__)); 96 97 #define BTRFS_FSID_SIZE 16 98 /* 99 * every tree block (leaf or node) starts with this header. 100 */ 101 struct btrfs_header { 102 u8 csum[BTRFS_CSUM_SIZE]; 103 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */ 104 __le64 bytenr; /* which block this node is supposed to live in */ 105 __le64 generation; 106 __le64 owner; 107 __le32 nritems; 108 __le16 flags; 109 u8 level; 110 } __attribute__ ((__packed__)); 111 112 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \ 113 sizeof(struct btrfs_header)) / \ 114 sizeof(struct btrfs_key_ptr)) 115 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header)) 116 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize)) 117 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \ 118 sizeof(struct btrfs_item) - \ 119 sizeof(struct btrfs_file_extent_item)) 120 121 /* 122 * the super block basically lists the main trees of the FS 123 * it currently lacks any block count etc etc 124 */ 125 struct btrfs_super_block { 126 u8 csum[BTRFS_CSUM_SIZE]; 127 /* the first 3 fields must match struct btrfs_header */ 128 u8 fsid[16]; /* FS specific uuid */ 129 __le64 bytenr; /* this block number */ 130 __le64 magic; 131 __le64 generation; 132 __le64 root; 133 __le64 total_bytes; 134 __le64 bytes_used; 135 __le64 root_dir_objectid; 136 __le32 sectorsize; 137 __le32 nodesize; 138 __le32 leafsize; 139 __le32 stripesize; 140 u8 root_level; 141 } __attribute__ ((__packed__)); 142 143 /* 144 * A leaf is full of items. offset and size tell us where to find 145 * the item in the leaf (relative to the start of the data area) 146 */ 147 struct btrfs_item { 148 struct btrfs_disk_key key; 149 __le32 offset; 150 __le32 size; 151 } __attribute__ ((__packed__)); 152 153 /* 154 * leaves have an item area and a data area: 155 * [item0, item1....itemN] [free space] [dataN...data1, data0] 156 * 157 * The data is separate from the items to get the keys closer together 158 * during searches. 159 */ 160 struct btrfs_leaf { 161 struct btrfs_header header; 162 struct btrfs_item items[]; 163 } __attribute__ ((__packed__)); 164 165 /* 166 * all non-leaf blocks are nodes, they hold only keys and pointers to 167 * other blocks 168 */ 169 struct btrfs_key_ptr { 170 struct btrfs_disk_key key; 171 __le64 blockptr; 172 __le64 generation; 173 } __attribute__ ((__packed__)); 174 175 struct btrfs_node { 176 struct btrfs_header header; 177 struct btrfs_key_ptr ptrs[]; 178 } __attribute__ ((__packed__)); 179 180 /* 181 * btrfs_paths remember the path taken from the root down to the leaf. 182 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point 183 * to any other levels that are present. 184 * 185 * The slots array records the index of the item or block pointer 186 * used while walking the tree. 187 */ 188 struct btrfs_path { 189 struct extent_buffer *nodes[BTRFS_MAX_LEVEL]; 190 int slots[BTRFS_MAX_LEVEL]; 191 int reada; 192 int lowest_level; 193 }; 194 195 /* 196 * items in the extent btree are used to record the objectid of the 197 * owner of the block and the number of references 198 */ 199 struct btrfs_extent_item { 200 __le32 refs; 201 } __attribute__ ((__packed__)); 202 203 struct btrfs_extent_ref { 204 __le64 root; 205 __le64 generation; 206 __le64 objectid; 207 __le64 offset; 208 } __attribute__ ((__packed__)); 209 210 struct btrfs_inode_ref { 211 __le16 name_len; 212 /* name goes here */ 213 } __attribute__ ((__packed__)); 214 215 struct btrfs_inode_timespec { 216 __le64 sec; 217 __le32 nsec; 218 } __attribute__ ((__packed__)); 219 220 /* 221 * there is no padding here on purpose. If you want to extent the inode, 222 * make a new item type 223 */ 224 struct btrfs_inode_item { 225 __le64 generation; 226 __le64 size; 227 __le64 nblocks; 228 __le64 block_group; 229 __le32 nlink; 230 __le32 uid; 231 __le32 gid; 232 __le32 mode; 233 __le32 rdev; 234 __le16 flags; 235 __le16 compat_flags; 236 struct btrfs_inode_timespec atime; 237 struct btrfs_inode_timespec ctime; 238 struct btrfs_inode_timespec mtime; 239 struct btrfs_inode_timespec otime; 240 } __attribute__ ((__packed__)); 241 242 struct btrfs_dir_item { 243 struct btrfs_disk_key location; 244 __le16 data_len; 245 __le16 name_len; 246 u8 type; 247 } __attribute__ ((__packed__)); 248 249 struct btrfs_root_item { 250 struct btrfs_inode_item inode; 251 __le64 root_dirid; 252 __le64 bytenr; 253 __le64 byte_limit; 254 __le64 bytes_used; 255 __le32 flags; 256 __le32 refs; 257 struct btrfs_disk_key drop_progress; 258 u8 drop_level; 259 u8 level; 260 } __attribute__ ((__packed__)); 261 262 #define BTRFS_FILE_EXTENT_REG 0 263 #define BTRFS_FILE_EXTENT_INLINE 1 264 265 struct btrfs_file_extent_item { 266 __le64 generation; 267 u8 type; 268 /* 269 * disk space consumed by the extent, checksum blocks are included 270 * in these numbers 271 */ 272 __le64 disk_bytenr; 273 __le64 disk_num_bytes; 274 /* 275 * the logical offset in file blocks (no csums) 276 * this extent record is for. This allows a file extent to point 277 * into the middle of an existing extent on disk, sharing it 278 * between two snapshots (useful if some bytes in the middle of the 279 * extent have changed 280 */ 281 __le64 offset; 282 /* 283 * the logical number of file blocks (no csums included) 284 */ 285 __le64 num_bytes; 286 } __attribute__ ((__packed__)); 287 288 struct btrfs_csum_item { 289 u8 csum; 290 } __attribute__ ((__packed__)); 291 292 /* tag for the radix tree of block groups in ram */ 293 #define BTRFS_BLOCK_GROUP_SIZE (256 * 1024 * 1024) 294 295 296 #define BTRFS_BLOCK_GROUP_DATA 1 297 #define BTRFS_BLOCK_GROUP_MIXED 2 298 299 struct btrfs_block_group_item { 300 __le64 used; 301 u8 flags; 302 } __attribute__ ((__packed__)); 303 304 struct btrfs_block_group_cache { 305 struct btrfs_key key; 306 struct btrfs_block_group_item item; 307 int data; 308 int cached; 309 u64 pinned; 310 }; 311 struct btrfs_fs_info { 312 u8 fsid[BTRFS_FSID_SIZE]; 313 struct btrfs_root *extent_root; 314 struct btrfs_root *tree_root; 315 struct radix_tree_root fs_roots_radix; 316 317 struct extent_map_tree free_space_cache; 318 struct extent_map_tree block_group_cache; 319 struct extent_map_tree pinned_extents; 320 struct extent_map_tree pending_del; 321 struct extent_map_tree extent_ins; 322 323 u64 generation; 324 u64 last_trans_committed; 325 unsigned long mount_opt; 326 u64 max_extent; 327 struct btrfs_transaction *running_transaction; 328 struct btrfs_super_block super_copy; 329 struct extent_buffer *sb_buffer; 330 struct super_block *sb; 331 struct inode *btree_inode; 332 spinlock_t hash_lock; 333 struct mutex trans_mutex; 334 struct mutex fs_mutex; 335 struct list_head trans_list; 336 struct list_head hashers; 337 struct list_head dead_roots; 338 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18) 339 struct work_struct trans_work; 340 #else 341 struct delayed_work trans_work; 342 #endif 343 struct kobject super_kobj; 344 struct completion kobj_unregister; 345 int do_barriers; 346 int closing; 347 348 u64 total_pinned; 349 }; 350 /* 351 * in ram representation of the tree. extent_root is used for all allocations 352 * and for the extent tree extent_root root. 353 */ 354 struct btrfs_root { 355 struct extent_buffer *node; 356 struct extent_buffer *commit_root; 357 struct btrfs_root_item root_item; 358 struct btrfs_key root_key; 359 struct btrfs_fs_info *fs_info; 360 struct inode *inode; 361 struct kobject root_kobj; 362 struct completion kobj_unregister; 363 struct rw_semaphore snap_sem; 364 u64 objectid; 365 u64 last_trans; 366 367 /* data allocations are done in sectorsize units */ 368 u32 sectorsize; 369 370 /* node allocations are done in nodesize units */ 371 u32 nodesize; 372 373 /* leaf allocations are done in leafsize units */ 374 u32 leafsize; 375 376 u32 stripesize; 377 378 u32 type; 379 u64 highest_inode; 380 u64 last_inode_alloc; 381 int ref_cows; 382 struct btrfs_key defrag_progress; 383 int defrag_running; 384 int defrag_level; 385 char *name; 386 }; 387 388 /* 389 * inode items have the data typically returned from stat and store other 390 * info about object characteristics. There is one for every file and dir in 391 * the FS 392 */ 393 #define BTRFS_INODE_ITEM_KEY 1 394 #define BTRFS_INODE_REF_KEY 2 395 #define BTRFS_XATTR_ITEM_KEY 8 396 /* reserve 2-15 close to the inode for later flexibility */ 397 398 /* 399 * dir items are the name -> inode pointers in a directory. There is one 400 * for every name in a directory. 401 */ 402 #define BTRFS_DIR_ITEM_KEY 16 403 #define BTRFS_DIR_INDEX_KEY 17 404 /* 405 * extent data is for file data 406 */ 407 #define BTRFS_EXTENT_DATA_KEY 18 408 /* 409 * csum items have the checksums for data in the extents 410 */ 411 #define BTRFS_CSUM_ITEM_KEY 19 412 413 /* reserve 20-31 for other file stuff */ 414 415 /* 416 * root items point to tree roots. There are typically in the root 417 * tree used by the super block to find all the other trees 418 */ 419 #define BTRFS_ROOT_ITEM_KEY 32 420 /* 421 * extent items are in the extent map tree. These record which blocks 422 * are used, and how many references there are to each block 423 */ 424 #define BTRFS_EXTENT_ITEM_KEY 33 425 #define BTRFS_EXTENT_REF_KEY 34 426 427 /* 428 * block groups give us hints into the extent allocation trees. Which 429 * blocks are free etc etc 430 */ 431 #define BTRFS_BLOCK_GROUP_ITEM_KEY 50 432 433 /* 434 * string items are for debugging. They just store a short string of 435 * data in the FS 436 */ 437 #define BTRFS_STRING_ITEM_KEY 253 438 439 #define BTRFS_MOUNT_NODATASUM 0x1 440 #define BTRFS_MOUNT_NODATACOW 0x2 441 442 #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) 443 #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) 444 #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \ 445 BTRFS_MOUNT_##opt) 446 447 /* some macros to generate set/get funcs for the struct fields. This 448 * assumes there is a lefoo_to_cpu for every type, so lets make a simple 449 * one for u8: 450 */ 451 #define le8_to_cpu(v) (v) 452 #define cpu_to_le8(v) (v) 453 #define __le8 u8 454 455 #define read_eb_member(eb, ptr, type, member, result) ( \ 456 read_extent_buffer(eb, (char *)(result), \ 457 ((unsigned long)(ptr)) + \ 458 offsetof(type, member), \ 459 sizeof(((type *)0)->member))) 460 461 #define write_eb_member(eb, ptr, type, member, result) ( \ 462 write_extent_buffer(eb, (char *)(result), \ 463 ((unsigned long)(ptr)) + \ 464 offsetof(type, member), \ 465 sizeof(((type *)0)->member))) 466 467 #ifndef BTRFS_SETGET_FUNCS 468 #define BTRFS_SETGET_FUNCS(name, type, member, bits) \ 469 u##bits btrfs_##name(struct extent_buffer *eb, type *s); \ 470 void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val); 471 #endif 472 473 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \ 474 static inline u##bits btrfs_##name(struct extent_buffer *eb) \ 475 { \ 476 char *kaddr = kmap_atomic(eb->first_page, KM_USER0); \ 477 unsigned long offset = offsetof(type, member); \ 478 u##bits res; \ 479 __le##bits *tmp = (__le##bits *)(kaddr + offset); \ 480 res = le##bits##_to_cpu(*tmp); \ 481 kunmap_atomic(kaddr, KM_USER0); \ 482 return res; \ 483 } \ 484 static inline void btrfs_set_##name(struct extent_buffer *eb, \ 485 u##bits val) \ 486 { \ 487 char *kaddr = kmap_atomic(eb->first_page, KM_USER0); \ 488 unsigned long offset = offsetof(type, member); \ 489 __le##bits *tmp = (__le##bits *)(kaddr + offset); \ 490 *tmp = cpu_to_le##bits(val); \ 491 kunmap_atomic(kaddr, KM_USER0); \ 492 } 493 494 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \ 495 static inline u##bits btrfs_##name(type *s) \ 496 { \ 497 return le##bits##_to_cpu(s->member); \ 498 } \ 499 static inline void btrfs_set_##name(type *s, u##bits val) \ 500 { \ 501 s->member = cpu_to_le##bits(val); \ 502 } 503 504 /* struct btrfs_block_group_item */ 505 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item, 506 used, 64); 507 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item, 508 used, 64); 509 510 /* struct btrfs_inode_ref */ 511 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); 512 513 /* struct btrfs_inode_item */ 514 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64); 515 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64); 516 BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64); 517 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64); 518 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32); 519 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32); 520 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32); 521 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32); 522 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 32); 523 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16); 524 BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item, 525 compat_flags, 16); 526 527 static inline struct btrfs_inode_timespec * 528 btrfs_inode_atime(struct btrfs_inode_item *inode_item) 529 { 530 unsigned long ptr = (unsigned long)inode_item; 531 ptr += offsetof(struct btrfs_inode_item, atime); 532 return (struct btrfs_inode_timespec *)ptr; 533 } 534 535 static inline struct btrfs_inode_timespec * 536 btrfs_inode_mtime(struct btrfs_inode_item *inode_item) 537 { 538 unsigned long ptr = (unsigned long)inode_item; 539 ptr += offsetof(struct btrfs_inode_item, mtime); 540 return (struct btrfs_inode_timespec *)ptr; 541 } 542 543 static inline struct btrfs_inode_timespec * 544 btrfs_inode_ctime(struct btrfs_inode_item *inode_item) 545 { 546 unsigned long ptr = (unsigned long)inode_item; 547 ptr += offsetof(struct btrfs_inode_item, ctime); 548 return (struct btrfs_inode_timespec *)ptr; 549 } 550 551 static inline struct btrfs_inode_timespec * 552 btrfs_inode_otime(struct btrfs_inode_item *inode_item) 553 { 554 unsigned long ptr = (unsigned long)inode_item; 555 ptr += offsetof(struct btrfs_inode_item, otime); 556 return (struct btrfs_inode_timespec *)ptr; 557 } 558 559 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_inode_timespec, sec, 64); 560 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_inode_timespec, nsec, 32); 561 562 /* struct btrfs_extent_item */ 563 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32); 564 565 /* struct btrfs_extent_ref */ 566 BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64); 567 BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64); 568 BTRFS_SETGET_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64); 569 BTRFS_SETGET_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64); 570 571 BTRFS_SETGET_STACK_FUNCS(stack_ref_root, struct btrfs_extent_ref, root, 64); 572 BTRFS_SETGET_STACK_FUNCS(stack_ref_generation, struct btrfs_extent_ref, 573 generation, 64); 574 BTRFS_SETGET_STACK_FUNCS(stack_ref_objectid, struct btrfs_extent_ref, 575 objectid, 64); 576 BTRFS_SETGET_STACK_FUNCS(stack_ref_offset, struct btrfs_extent_ref, offset, 64); 577 578 BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item, 579 refs, 32); 580 581 /* struct btrfs_node */ 582 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); 583 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); 584 585 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) 586 { 587 unsigned long ptr; 588 ptr = offsetof(struct btrfs_node, ptrs) + 589 sizeof(struct btrfs_key_ptr) * nr; 590 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr); 591 } 592 593 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, 594 int nr, u64 val) 595 { 596 unsigned long ptr; 597 ptr = offsetof(struct btrfs_node, ptrs) + 598 sizeof(struct btrfs_key_ptr) * nr; 599 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val); 600 } 601 602 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) 603 { 604 unsigned long ptr; 605 ptr = offsetof(struct btrfs_node, ptrs) + 606 sizeof(struct btrfs_key_ptr) * nr; 607 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr); 608 } 609 610 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, 611 int nr, u64 val) 612 { 613 unsigned long ptr; 614 ptr = offsetof(struct btrfs_node, ptrs) + 615 sizeof(struct btrfs_key_ptr) * nr; 616 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val); 617 } 618 619 static inline unsigned long btrfs_node_key_ptr_offset(int nr) 620 { 621 return offsetof(struct btrfs_node, ptrs) + 622 sizeof(struct btrfs_key_ptr) * nr; 623 } 624 625 void btrfs_node_key(struct extent_buffer *eb, 626 struct btrfs_disk_key *disk_key, int nr); 627 628 static inline void btrfs_set_node_key(struct extent_buffer *eb, 629 struct btrfs_disk_key *disk_key, int nr) 630 { 631 unsigned long ptr; 632 ptr = btrfs_node_key_ptr_offset(nr); 633 write_eb_member(eb, (struct btrfs_key_ptr *)ptr, 634 struct btrfs_key_ptr, key, disk_key); 635 } 636 637 /* struct btrfs_item */ 638 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32); 639 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32); 640 641 static inline unsigned long btrfs_item_nr_offset(int nr) 642 { 643 return offsetof(struct btrfs_leaf, items) + 644 sizeof(struct btrfs_item) * nr; 645 } 646 647 static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb, 648 int nr) 649 { 650 return (struct btrfs_item *)btrfs_item_nr_offset(nr); 651 } 652 653 static inline u32 btrfs_item_end(struct extent_buffer *eb, 654 struct btrfs_item *item) 655 { 656 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item); 657 } 658 659 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) 660 { 661 return btrfs_item_end(eb, btrfs_item_nr(eb, nr)); 662 } 663 664 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr) 665 { 666 return btrfs_item_offset(eb, btrfs_item_nr(eb, nr)); 667 } 668 669 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) 670 { 671 return btrfs_item_size(eb, btrfs_item_nr(eb, nr)); 672 } 673 674 static inline void btrfs_item_key(struct extent_buffer *eb, 675 struct btrfs_disk_key *disk_key, int nr) 676 { 677 struct btrfs_item *item = btrfs_item_nr(eb, nr); 678 read_eb_member(eb, item, struct btrfs_item, key, disk_key); 679 } 680 681 static inline void btrfs_set_item_key(struct extent_buffer *eb, 682 struct btrfs_disk_key *disk_key, int nr) 683 { 684 struct btrfs_item *item = btrfs_item_nr(eb, nr); 685 write_eb_member(eb, item, struct btrfs_item, key, disk_key); 686 } 687 688 /* struct btrfs_dir_item */ 689 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16); 690 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8); 691 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16); 692 693 static inline void btrfs_dir_item_key(struct extent_buffer *eb, 694 struct btrfs_dir_item *item, 695 struct btrfs_disk_key *key) 696 { 697 read_eb_member(eb, item, struct btrfs_dir_item, location, key); 698 } 699 700 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb, 701 struct btrfs_dir_item *item, 702 struct btrfs_disk_key *key) 703 { 704 write_eb_member(eb, item, struct btrfs_dir_item, location, key); 705 } 706 707 /* struct btrfs_disk_key */ 708 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key, 709 objectid, 64); 710 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64); 711 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8); 712 713 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu, 714 struct btrfs_disk_key *disk) 715 { 716 cpu->offset = le64_to_cpu(disk->offset); 717 cpu->type = disk->type; 718 cpu->objectid = le64_to_cpu(disk->objectid); 719 } 720 721 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk, 722 struct btrfs_key *cpu) 723 { 724 disk->offset = cpu_to_le64(cpu->offset); 725 disk->type = cpu->type; 726 disk->objectid = cpu_to_le64(cpu->objectid); 727 } 728 729 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb, 730 struct btrfs_key *key, int nr) 731 { 732 struct btrfs_disk_key disk_key; 733 btrfs_node_key(eb, &disk_key, nr); 734 btrfs_disk_key_to_cpu(key, &disk_key); 735 } 736 737 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb, 738 struct btrfs_key *key, int nr) 739 { 740 struct btrfs_disk_key disk_key; 741 btrfs_item_key(eb, &disk_key, nr); 742 btrfs_disk_key_to_cpu(key, &disk_key); 743 } 744 745 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb, 746 struct btrfs_dir_item *item, 747 struct btrfs_key *key) 748 { 749 struct btrfs_disk_key disk_key; 750 btrfs_dir_item_key(eb, item, &disk_key); 751 btrfs_disk_key_to_cpu(key, &disk_key); 752 } 753 754 755 static inline u8 btrfs_key_type(struct btrfs_key *key) 756 { 757 return key->type; 758 } 759 760 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val) 761 { 762 key->type = val; 763 } 764 765 /* struct btrfs_header */ 766 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64); 767 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header, 768 generation, 64); 769 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64); 770 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32); 771 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 16); 772 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8); 773 774 static inline u8 *btrfs_header_fsid(struct extent_buffer *eb) 775 { 776 unsigned long ptr = offsetof(struct btrfs_header, fsid); 777 return (u8 *)ptr; 778 } 779 780 static inline u8 *btrfs_super_fsid(struct extent_buffer *eb) 781 { 782 unsigned long ptr = offsetof(struct btrfs_super_block, fsid); 783 return (u8 *)ptr; 784 } 785 786 static inline u8 *btrfs_header_csum(struct extent_buffer *eb) 787 { 788 unsigned long ptr = offsetof(struct btrfs_header, csum); 789 return (u8 *)ptr; 790 } 791 792 static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb) 793 { 794 return NULL; 795 } 796 797 static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb) 798 { 799 return NULL; 800 } 801 802 static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb) 803 { 804 return NULL; 805 } 806 807 static inline int btrfs_is_leaf(struct extent_buffer *eb) 808 { 809 return (btrfs_header_level(eb) == 0); 810 } 811 812 /* struct btrfs_root_item */ 813 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32); 814 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64); 815 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8); 816 817 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64); 818 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8); 819 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64); 820 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32); 821 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32); 822 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64); 823 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64); 824 825 /* struct btrfs_super_block */ 826 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64); 827 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block, 828 generation, 64); 829 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64); 830 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block, 831 root_level, 8); 832 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block, 833 total_bytes, 64); 834 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block, 835 bytes_used, 64); 836 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block, 837 sectorsize, 32); 838 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block, 839 nodesize, 32); 840 BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block, 841 leafsize, 32); 842 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block, 843 stripesize, 32); 844 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block, 845 root_dir_objectid, 64); 846 847 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) 848 { 849 return offsetof(struct btrfs_leaf, items); 850 } 851 852 /* struct btrfs_file_extent_item */ 853 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8); 854 855 static inline unsigned long btrfs_file_extent_inline_start(struct 856 btrfs_file_extent_item *e) 857 { 858 unsigned long offset = (unsigned long)e; 859 offset += offsetof(struct btrfs_file_extent_item, disk_bytenr); 860 return offset; 861 } 862 863 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize) 864 { 865 return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize; 866 } 867 868 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb, 869 struct btrfs_item *e) 870 { 871 unsigned long offset; 872 offset = offsetof(struct btrfs_file_extent_item, disk_bytenr); 873 return btrfs_item_size(eb, e) - offset; 874 } 875 876 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item, 877 disk_bytenr, 64); 878 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item, 879 generation, 64); 880 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item, 881 disk_num_bytes, 64); 882 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item, 883 offset, 64); 884 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item, 885 num_bytes, 64); 886 887 static inline struct btrfs_root *btrfs_sb(struct super_block *sb) 888 { 889 return sb->s_fs_info; 890 } 891 892 static inline int btrfs_set_root_name(struct btrfs_root *root, 893 const char *name, int len) 894 { 895 /* if we already have a name just free it */ 896 if (root->name) 897 kfree(root->name); 898 899 root->name = kmalloc(len+1, GFP_KERNEL); 900 if (!root->name) 901 return -ENOMEM; 902 903 memcpy(root->name, name, len); 904 root->name[len] ='\0'; 905 906 return 0; 907 } 908 909 static inline u32 btrfs_level_size(struct btrfs_root *root, int level) { 910 if (level == 0) 911 return root->leafsize; 912 return root->nodesize; 913 } 914 915 /* helper function to cast into the data area of the leaf. */ 916 #define btrfs_item_ptr(leaf, slot, type) \ 917 ((type *)(btrfs_leaf_data(leaf) + \ 918 btrfs_item_offset_nr(leaf, slot))) 919 920 #define btrfs_item_ptr_offset(leaf, slot) \ 921 ((unsigned long)(btrfs_leaf_data(leaf) + \ 922 btrfs_item_offset_nr(leaf, slot))) 923 924 static inline struct dentry *fdentry(struct file *file) { 925 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18) 926 return file->f_dentry; 927 #else 928 return file->f_path.dentry; 929 #endif 930 } 931 932 /* extent-tree.c */ 933 u32 btrfs_count_snapshots_in_path(struct btrfs_root *root, 934 struct btrfs_path *count_path, 935 u64 first_extent); 936 int btrfs_extent_post_op(struct btrfs_trans_handle *trans, 937 struct btrfs_root *root); 938 int btrfs_copy_pinned(struct btrfs_root *root, struct extent_map_tree *copy); 939 struct btrfs_block_group_cache *btrfs_lookup_block_group(struct 940 btrfs_fs_info *info, 941 u64 bytenr); 942 struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root, 943 struct btrfs_block_group_cache 944 *hint, u64 search_start, 945 int data, int owner); 946 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans, 947 struct btrfs_root *root, u64 owner_objectid); 948 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 949 struct btrfs_root *root, u32 size, 950 u64 root_objectid, 951 u64 hint, u64 empty_size); 952 struct extent_buffer *__btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 953 struct btrfs_root *root, 954 u32 blocksize, 955 u64 root_objectid, 956 u64 ref_generation, 957 u64 first_objectid, 958 int level, 959 u64 hint, 960 u64 empty_size); 961 int btrfs_insert_extent_backref(struct btrfs_trans_handle *trans, 962 struct btrfs_root *root, 963 struct btrfs_path *path, u64 bytenr, 964 u64 root_objectid, u64 ref_generation, 965 u64 owner, u64 owner_offset); 966 int btrfs_alloc_extent(struct btrfs_trans_handle *trans, 967 struct btrfs_root *root, 968 u64 num_bytes, u64 root_objectid, u64 ref_generation, 969 u64 owner, u64 owner_offset, 970 u64 empty_size, u64 hint_byte, 971 u64 search_end, struct btrfs_key *ins, int data); 972 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 973 struct extent_buffer *buf); 974 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root 975 *root, u64 bytenr, u64 num_bytes, 976 u64 root_objectid, u64 ref_generation, 977 u64 owner_objectid, u64 owner_offset, int pin); 978 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, 979 struct btrfs_root *root, 980 struct extent_map_tree *unpin); 981 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, 982 struct btrfs_root *root, 983 u64 bytenr, u64 num_bytes, 984 u64 root_objectid, u64 ref_generation, 985 u64 owner, u64 owner_offset); 986 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 987 struct btrfs_root *root); 988 int btrfs_free_block_groups(struct btrfs_fs_info *info); 989 int btrfs_read_block_groups(struct btrfs_root *root); 990 /* ctree.c */ 991 int btrfs_cow_block(struct btrfs_trans_handle *trans, 992 struct btrfs_root *root, struct extent_buffer *buf, 993 struct extent_buffer *parent, int parent_slot, 994 struct extent_buffer **cow_ret); 995 int btrfs_copy_root(struct btrfs_trans_handle *trans, 996 struct btrfs_root *root, 997 struct extent_buffer *buf, 998 struct extent_buffer **cow_ret, u64 new_root_objectid); 999 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root 1000 *root, struct btrfs_path *path, u32 data_size); 1001 int btrfs_truncate_item(struct btrfs_trans_handle *trans, 1002 struct btrfs_root *root, 1003 struct btrfs_path *path, 1004 u32 new_size, int from_end); 1005 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root 1006 *root, struct btrfs_key *key, struct btrfs_path *p, int 1007 ins_len, int cow); 1008 int btrfs_realloc_node(struct btrfs_trans_handle *trans, 1009 struct btrfs_root *root, struct extent_buffer *parent, 1010 int start_slot, int cache_only, u64 *last_ret, 1011 struct btrfs_key *progress); 1012 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p); 1013 struct btrfs_path *btrfs_alloc_path(void); 1014 void btrfs_free_path(struct btrfs_path *p); 1015 void btrfs_init_path(struct btrfs_path *p); 1016 int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 1017 struct btrfs_path *path); 1018 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root 1019 *root, struct btrfs_key *key, void *data, u32 data_size); 1020 int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root 1021 *root, struct btrfs_path *path, struct btrfs_key 1022 *cpu_key, u32 data_size); 1023 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path); 1024 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); 1025 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); 1026 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root 1027 *root); 1028 /* root-item.c */ 1029 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, 1030 struct btrfs_key *key); 1031 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root 1032 *root, struct btrfs_key *key, struct btrfs_root_item 1033 *item); 1034 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root 1035 *root, struct btrfs_key *key, struct btrfs_root_item 1036 *item); 1037 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct 1038 btrfs_root_item *item, struct btrfs_key *key); 1039 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid, 1040 struct btrfs_root *latest_root); 1041 /* dir-item.c */ 1042 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root 1043 *root, const char *name, int name_len, u64 dir, 1044 struct btrfs_key *location, u8 type); 1045 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, 1046 struct btrfs_root *root, 1047 struct btrfs_path *path, u64 dir, 1048 const char *name, int name_len, 1049 int mod); 1050 struct btrfs_dir_item * 1051 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans, 1052 struct btrfs_root *root, 1053 struct btrfs_path *path, u64 dir, 1054 u64 objectid, const char *name, int name_len, 1055 int mod); 1056 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, 1057 struct btrfs_path *path, 1058 const char *name, int name_len); 1059 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, 1060 struct btrfs_root *root, 1061 struct btrfs_path *path, 1062 struct btrfs_dir_item *di); 1063 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, 1064 struct btrfs_root *root, const char *name, 1065 u16 name_len, const void *data, u16 data_len, 1066 u64 dir); 1067 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans, 1068 struct btrfs_root *root, 1069 struct btrfs_path *path, u64 dir, 1070 const char *name, u16 name_len, 1071 int mod); 1072 /* inode-map.c */ 1073 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans, 1074 struct btrfs_root *fs_root, 1075 u64 dirid, u64 *objectid); 1076 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid); 1077 1078 /* inode-item.c */ 1079 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, 1080 struct btrfs_root *root, 1081 const char *name, int name_len, 1082 u64 inode_objectid, u64 ref_objectid); 1083 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 1084 struct btrfs_root *root, 1085 const char *name, int name_len, 1086 u64 inode_objectid, u64 ref_objectid); 1087 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, 1088 struct btrfs_root *root, 1089 struct btrfs_path *path, u64 objectid); 1090 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root 1091 *root, struct btrfs_path *path, 1092 struct btrfs_key *location, int mod); 1093 1094 /* file-item.c */ 1095 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 1096 struct btrfs_root *root, 1097 u64 objectid, u64 pos, u64 offset, 1098 u64 disk_num_bytes, 1099 u64 num_bytes); 1100 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 1101 struct btrfs_root *root, 1102 struct btrfs_path *path, u64 objectid, 1103 u64 bytenr, int mod); 1104 int btrfs_csum_file_block(struct btrfs_trans_handle *trans, 1105 struct btrfs_root *root, 1106 struct inode *inode, 1107 u64 objectid, u64 offset, 1108 char *data, size_t len); 1109 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans, 1110 struct btrfs_root *root, 1111 struct btrfs_path *path, 1112 u64 objectid, u64 offset, 1113 int cow); 1114 int btrfs_csum_truncate(struct btrfs_trans_handle *trans, 1115 struct btrfs_root *root, struct btrfs_path *path, 1116 u64 isize); 1117 /* inode.c */ 1118 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page); 1119 int btrfs_readpage(struct file *file, struct page *page); 1120 void btrfs_delete_inode(struct inode *inode); 1121 void btrfs_read_locked_inode(struct inode *inode); 1122 int btrfs_write_inode(struct inode *inode, int wait); 1123 void btrfs_dirty_inode(struct inode *inode); 1124 struct inode *btrfs_alloc_inode(struct super_block *sb); 1125 void btrfs_destroy_inode(struct inode *inode); 1126 int btrfs_init_cachep(void); 1127 void btrfs_destroy_cachep(void); 1128 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 1129 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid, 1130 struct btrfs_root *root); 1131 int btrfs_commit_write(struct file *file, struct page *page, 1132 unsigned from, unsigned to); 1133 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 1134 size_t page_offset, u64 start, u64 end, 1135 int create); 1136 int btrfs_update_inode(struct btrfs_trans_handle *trans, 1137 struct btrfs_root *root, 1138 struct inode *inode); 1139 /* file.c */ 1140 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end); 1141 extern struct file_operations btrfs_file_operations; 1142 int btrfs_drop_extents(struct btrfs_trans_handle *trans, 1143 struct btrfs_root *root, struct inode *inode, 1144 u64 start, u64 end, u64 inline_limit, u64 *hint_block); 1145 /* tree-defrag.c */ 1146 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, 1147 struct btrfs_root *root, int cache_only); 1148 1149 /* sysfs.c */ 1150 int btrfs_init_sysfs(void); 1151 void btrfs_exit_sysfs(void); 1152 int btrfs_sysfs_add_super(struct btrfs_fs_info *fs); 1153 int btrfs_sysfs_add_root(struct btrfs_root *root); 1154 void btrfs_sysfs_del_root(struct btrfs_root *root); 1155 void btrfs_sysfs_del_super(struct btrfs_fs_info *root); 1156 1157 /* xattr.c */ 1158 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size); 1159 int btrfs_delete_xattrs(struct btrfs_trans_handle *trans, 1160 struct btrfs_root *root, struct inode *inode); 1161 #endif 1162