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 spinlock_t delalloc_lock; 350 u64 delalloc_bytes; 351 }; 352 /* 353 * in ram representation of the tree. extent_root is used for all allocations 354 * and for the extent tree extent_root root. 355 */ 356 struct btrfs_root { 357 struct extent_buffer *node; 358 struct extent_buffer *commit_root; 359 struct btrfs_root_item root_item; 360 struct btrfs_key root_key; 361 struct btrfs_fs_info *fs_info; 362 struct inode *inode; 363 struct kobject root_kobj; 364 struct completion kobj_unregister; 365 struct rw_semaphore snap_sem; 366 u64 objectid; 367 u64 last_trans; 368 369 /* data allocations are done in sectorsize units */ 370 u32 sectorsize; 371 372 /* node allocations are done in nodesize units */ 373 u32 nodesize; 374 375 /* leaf allocations are done in leafsize units */ 376 u32 leafsize; 377 378 u32 stripesize; 379 380 u32 type; 381 u64 highest_inode; 382 u64 last_inode_alloc; 383 int ref_cows; 384 struct btrfs_key defrag_progress; 385 int defrag_running; 386 int defrag_level; 387 char *name; 388 }; 389 390 /* 391 * inode items have the data typically returned from stat and store other 392 * info about object characteristics. There is one for every file and dir in 393 * the FS 394 */ 395 #define BTRFS_INODE_ITEM_KEY 1 396 #define BTRFS_INODE_REF_KEY 2 397 #define BTRFS_XATTR_ITEM_KEY 8 398 /* reserve 2-15 close to the inode for later flexibility */ 399 400 /* 401 * dir items are the name -> inode pointers in a directory. There is one 402 * for every name in a directory. 403 */ 404 #define BTRFS_DIR_ITEM_KEY 16 405 #define BTRFS_DIR_INDEX_KEY 17 406 /* 407 * extent data is for file data 408 */ 409 #define BTRFS_EXTENT_DATA_KEY 18 410 /* 411 * csum items have the checksums for data in the extents 412 */ 413 #define BTRFS_CSUM_ITEM_KEY 19 414 415 /* reserve 20-31 for other file stuff */ 416 417 /* 418 * root items point to tree roots. There are typically in the root 419 * tree used by the super block to find all the other trees 420 */ 421 #define BTRFS_ROOT_ITEM_KEY 32 422 /* 423 * extent items are in the extent map tree. These record which blocks 424 * are used, and how many references there are to each block 425 */ 426 #define BTRFS_EXTENT_ITEM_KEY 33 427 #define BTRFS_EXTENT_REF_KEY 34 428 429 /* 430 * block groups give us hints into the extent allocation trees. Which 431 * blocks are free etc etc 432 */ 433 #define BTRFS_BLOCK_GROUP_ITEM_KEY 50 434 435 /* 436 * string items are for debugging. They just store a short string of 437 * data in the FS 438 */ 439 #define BTRFS_STRING_ITEM_KEY 253 440 441 #define BTRFS_MOUNT_NODATASUM 0x1 442 #define BTRFS_MOUNT_NODATACOW 0x2 443 444 #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) 445 #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) 446 #define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \ 447 BTRFS_MOUNT_##opt) 448 449 /* some macros to generate set/get funcs for the struct fields. This 450 * assumes there is a lefoo_to_cpu for every type, so lets make a simple 451 * one for u8: 452 */ 453 #define le8_to_cpu(v) (v) 454 #define cpu_to_le8(v) (v) 455 #define __le8 u8 456 457 #define read_eb_member(eb, ptr, type, member, result) ( \ 458 read_extent_buffer(eb, (char *)(result), \ 459 ((unsigned long)(ptr)) + \ 460 offsetof(type, member), \ 461 sizeof(((type *)0)->member))) 462 463 #define write_eb_member(eb, ptr, type, member, result) ( \ 464 write_extent_buffer(eb, (char *)(result), \ 465 ((unsigned long)(ptr)) + \ 466 offsetof(type, member), \ 467 sizeof(((type *)0)->member))) 468 469 #ifndef BTRFS_SETGET_FUNCS 470 #define BTRFS_SETGET_FUNCS(name, type, member, bits) \ 471 u##bits btrfs_##name(struct extent_buffer *eb, type *s); \ 472 void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val); 473 #endif 474 475 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \ 476 static inline u##bits btrfs_##name(struct extent_buffer *eb) \ 477 { \ 478 char *kaddr = kmap_atomic(eb->first_page, KM_USER0); \ 479 unsigned long offset = offsetof(type, member); \ 480 u##bits res; \ 481 __le##bits *tmp = (__le##bits *)(kaddr + offset); \ 482 res = le##bits##_to_cpu(*tmp); \ 483 kunmap_atomic(kaddr, KM_USER0); \ 484 return res; \ 485 } \ 486 static inline void btrfs_set_##name(struct extent_buffer *eb, \ 487 u##bits val) \ 488 { \ 489 char *kaddr = kmap_atomic(eb->first_page, KM_USER0); \ 490 unsigned long offset = offsetof(type, member); \ 491 __le##bits *tmp = (__le##bits *)(kaddr + offset); \ 492 *tmp = cpu_to_le##bits(val); \ 493 kunmap_atomic(kaddr, KM_USER0); \ 494 } 495 496 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \ 497 static inline u##bits btrfs_##name(type *s) \ 498 { \ 499 return le##bits##_to_cpu(s->member); \ 500 } \ 501 static inline void btrfs_set_##name(type *s, u##bits val) \ 502 { \ 503 s->member = cpu_to_le##bits(val); \ 504 } 505 506 /* struct btrfs_block_group_item */ 507 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item, 508 used, 64); 509 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item, 510 used, 64); 511 512 /* struct btrfs_inode_ref */ 513 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16); 514 515 /* struct btrfs_inode_item */ 516 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64); 517 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64); 518 BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64); 519 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64); 520 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32); 521 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32); 522 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32); 523 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32); 524 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 32); 525 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16); 526 BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item, 527 compat_flags, 16); 528 529 static inline struct btrfs_inode_timespec * 530 btrfs_inode_atime(struct btrfs_inode_item *inode_item) 531 { 532 unsigned long ptr = (unsigned long)inode_item; 533 ptr += offsetof(struct btrfs_inode_item, atime); 534 return (struct btrfs_inode_timespec *)ptr; 535 } 536 537 static inline struct btrfs_inode_timespec * 538 btrfs_inode_mtime(struct btrfs_inode_item *inode_item) 539 { 540 unsigned long ptr = (unsigned long)inode_item; 541 ptr += offsetof(struct btrfs_inode_item, mtime); 542 return (struct btrfs_inode_timespec *)ptr; 543 } 544 545 static inline struct btrfs_inode_timespec * 546 btrfs_inode_ctime(struct btrfs_inode_item *inode_item) 547 { 548 unsigned long ptr = (unsigned long)inode_item; 549 ptr += offsetof(struct btrfs_inode_item, ctime); 550 return (struct btrfs_inode_timespec *)ptr; 551 } 552 553 static inline struct btrfs_inode_timespec * 554 btrfs_inode_otime(struct btrfs_inode_item *inode_item) 555 { 556 unsigned long ptr = (unsigned long)inode_item; 557 ptr += offsetof(struct btrfs_inode_item, otime); 558 return (struct btrfs_inode_timespec *)ptr; 559 } 560 561 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_inode_timespec, sec, 64); 562 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_inode_timespec, nsec, 32); 563 564 /* struct btrfs_extent_item */ 565 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32); 566 567 /* struct btrfs_extent_ref */ 568 BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64); 569 BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64); 570 BTRFS_SETGET_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64); 571 BTRFS_SETGET_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64); 572 573 BTRFS_SETGET_STACK_FUNCS(stack_ref_root, struct btrfs_extent_ref, root, 64); 574 BTRFS_SETGET_STACK_FUNCS(stack_ref_generation, struct btrfs_extent_ref, 575 generation, 64); 576 BTRFS_SETGET_STACK_FUNCS(stack_ref_objectid, struct btrfs_extent_ref, 577 objectid, 64); 578 BTRFS_SETGET_STACK_FUNCS(stack_ref_offset, struct btrfs_extent_ref, offset, 64); 579 580 BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item, 581 refs, 32); 582 583 /* struct btrfs_node */ 584 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64); 585 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64); 586 587 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr) 588 { 589 unsigned long ptr; 590 ptr = offsetof(struct btrfs_node, ptrs) + 591 sizeof(struct btrfs_key_ptr) * nr; 592 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr); 593 } 594 595 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb, 596 int nr, u64 val) 597 { 598 unsigned long ptr; 599 ptr = offsetof(struct btrfs_node, ptrs) + 600 sizeof(struct btrfs_key_ptr) * nr; 601 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val); 602 } 603 604 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr) 605 { 606 unsigned long ptr; 607 ptr = offsetof(struct btrfs_node, ptrs) + 608 sizeof(struct btrfs_key_ptr) * nr; 609 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr); 610 } 611 612 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb, 613 int nr, u64 val) 614 { 615 unsigned long ptr; 616 ptr = offsetof(struct btrfs_node, ptrs) + 617 sizeof(struct btrfs_key_ptr) * nr; 618 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val); 619 } 620 621 static inline unsigned long btrfs_node_key_ptr_offset(int nr) 622 { 623 return offsetof(struct btrfs_node, ptrs) + 624 sizeof(struct btrfs_key_ptr) * nr; 625 } 626 627 void btrfs_node_key(struct extent_buffer *eb, 628 struct btrfs_disk_key *disk_key, int nr); 629 630 static inline void btrfs_set_node_key(struct extent_buffer *eb, 631 struct btrfs_disk_key *disk_key, int nr) 632 { 633 unsigned long ptr; 634 ptr = btrfs_node_key_ptr_offset(nr); 635 write_eb_member(eb, (struct btrfs_key_ptr *)ptr, 636 struct btrfs_key_ptr, key, disk_key); 637 } 638 639 /* struct btrfs_item */ 640 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32); 641 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32); 642 643 static inline unsigned long btrfs_item_nr_offset(int nr) 644 { 645 return offsetof(struct btrfs_leaf, items) + 646 sizeof(struct btrfs_item) * nr; 647 } 648 649 static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb, 650 int nr) 651 { 652 return (struct btrfs_item *)btrfs_item_nr_offset(nr); 653 } 654 655 static inline u32 btrfs_item_end(struct extent_buffer *eb, 656 struct btrfs_item *item) 657 { 658 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item); 659 } 660 661 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr) 662 { 663 return btrfs_item_end(eb, btrfs_item_nr(eb, nr)); 664 } 665 666 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr) 667 { 668 return btrfs_item_offset(eb, btrfs_item_nr(eb, nr)); 669 } 670 671 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr) 672 { 673 return btrfs_item_size(eb, btrfs_item_nr(eb, nr)); 674 } 675 676 static inline void btrfs_item_key(struct extent_buffer *eb, 677 struct btrfs_disk_key *disk_key, int nr) 678 { 679 struct btrfs_item *item = btrfs_item_nr(eb, nr); 680 read_eb_member(eb, item, struct btrfs_item, key, disk_key); 681 } 682 683 static inline void btrfs_set_item_key(struct extent_buffer *eb, 684 struct btrfs_disk_key *disk_key, int nr) 685 { 686 struct btrfs_item *item = btrfs_item_nr(eb, nr); 687 write_eb_member(eb, item, struct btrfs_item, key, disk_key); 688 } 689 690 /* struct btrfs_dir_item */ 691 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16); 692 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8); 693 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16); 694 695 static inline void btrfs_dir_item_key(struct extent_buffer *eb, 696 struct btrfs_dir_item *item, 697 struct btrfs_disk_key *key) 698 { 699 read_eb_member(eb, item, struct btrfs_dir_item, location, key); 700 } 701 702 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb, 703 struct btrfs_dir_item *item, 704 struct btrfs_disk_key *key) 705 { 706 write_eb_member(eb, item, struct btrfs_dir_item, location, key); 707 } 708 709 /* struct btrfs_disk_key */ 710 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key, 711 objectid, 64); 712 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64); 713 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8); 714 715 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu, 716 struct btrfs_disk_key *disk) 717 { 718 cpu->offset = le64_to_cpu(disk->offset); 719 cpu->type = disk->type; 720 cpu->objectid = le64_to_cpu(disk->objectid); 721 } 722 723 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk, 724 struct btrfs_key *cpu) 725 { 726 disk->offset = cpu_to_le64(cpu->offset); 727 disk->type = cpu->type; 728 disk->objectid = cpu_to_le64(cpu->objectid); 729 } 730 731 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb, 732 struct btrfs_key *key, int nr) 733 { 734 struct btrfs_disk_key disk_key; 735 btrfs_node_key(eb, &disk_key, nr); 736 btrfs_disk_key_to_cpu(key, &disk_key); 737 } 738 739 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb, 740 struct btrfs_key *key, int nr) 741 { 742 struct btrfs_disk_key disk_key; 743 btrfs_item_key(eb, &disk_key, nr); 744 btrfs_disk_key_to_cpu(key, &disk_key); 745 } 746 747 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb, 748 struct btrfs_dir_item *item, 749 struct btrfs_key *key) 750 { 751 struct btrfs_disk_key disk_key; 752 btrfs_dir_item_key(eb, item, &disk_key); 753 btrfs_disk_key_to_cpu(key, &disk_key); 754 } 755 756 757 static inline u8 btrfs_key_type(struct btrfs_key *key) 758 { 759 return key->type; 760 } 761 762 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val) 763 { 764 key->type = val; 765 } 766 767 /* struct btrfs_header */ 768 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64); 769 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header, 770 generation, 64); 771 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64); 772 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32); 773 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 16); 774 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8); 775 776 static inline u8 *btrfs_header_fsid(struct extent_buffer *eb) 777 { 778 unsigned long ptr = offsetof(struct btrfs_header, fsid); 779 return (u8 *)ptr; 780 } 781 782 static inline u8 *btrfs_super_fsid(struct extent_buffer *eb) 783 { 784 unsigned long ptr = offsetof(struct btrfs_super_block, fsid); 785 return (u8 *)ptr; 786 } 787 788 static inline u8 *btrfs_header_csum(struct extent_buffer *eb) 789 { 790 unsigned long ptr = offsetof(struct btrfs_header, csum); 791 return (u8 *)ptr; 792 } 793 794 static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb) 795 { 796 return NULL; 797 } 798 799 static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb) 800 { 801 return NULL; 802 } 803 804 static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb) 805 { 806 return NULL; 807 } 808 809 static inline int btrfs_is_leaf(struct extent_buffer *eb) 810 { 811 return (btrfs_header_level(eb) == 0); 812 } 813 814 /* struct btrfs_root_item */ 815 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32); 816 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64); 817 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8); 818 819 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64); 820 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8); 821 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64); 822 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32); 823 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32); 824 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64); 825 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64); 826 827 /* struct btrfs_super_block */ 828 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64); 829 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block, 830 generation, 64); 831 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64); 832 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block, 833 root_level, 8); 834 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block, 835 total_bytes, 64); 836 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block, 837 bytes_used, 64); 838 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block, 839 sectorsize, 32); 840 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block, 841 nodesize, 32); 842 BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block, 843 leafsize, 32); 844 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block, 845 stripesize, 32); 846 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block, 847 root_dir_objectid, 64); 848 849 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l) 850 { 851 return offsetof(struct btrfs_leaf, items); 852 } 853 854 /* struct btrfs_file_extent_item */ 855 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8); 856 857 static inline unsigned long btrfs_file_extent_inline_start(struct 858 btrfs_file_extent_item *e) 859 { 860 unsigned long offset = (unsigned long)e; 861 offset += offsetof(struct btrfs_file_extent_item, disk_bytenr); 862 return offset; 863 } 864 865 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize) 866 { 867 return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize; 868 } 869 870 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb, 871 struct btrfs_item *e) 872 { 873 unsigned long offset; 874 offset = offsetof(struct btrfs_file_extent_item, disk_bytenr); 875 return btrfs_item_size(eb, e) - offset; 876 } 877 878 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item, 879 disk_bytenr, 64); 880 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item, 881 generation, 64); 882 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item, 883 disk_num_bytes, 64); 884 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item, 885 offset, 64); 886 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item, 887 num_bytes, 64); 888 889 static inline struct btrfs_root *btrfs_sb(struct super_block *sb) 890 { 891 return sb->s_fs_info; 892 } 893 894 static inline int btrfs_set_root_name(struct btrfs_root *root, 895 const char *name, int len) 896 { 897 /* if we already have a name just free it */ 898 if (root->name) 899 kfree(root->name); 900 901 root->name = kmalloc(len+1, GFP_KERNEL); 902 if (!root->name) 903 return -ENOMEM; 904 905 memcpy(root->name, name, len); 906 root->name[len] ='\0'; 907 908 return 0; 909 } 910 911 static inline u32 btrfs_level_size(struct btrfs_root *root, int level) { 912 if (level == 0) 913 return root->leafsize; 914 return root->nodesize; 915 } 916 917 /* helper function to cast into the data area of the leaf. */ 918 #define btrfs_item_ptr(leaf, slot, type) \ 919 ((type *)(btrfs_leaf_data(leaf) + \ 920 btrfs_item_offset_nr(leaf, slot))) 921 922 #define btrfs_item_ptr_offset(leaf, slot) \ 923 ((unsigned long)(btrfs_leaf_data(leaf) + \ 924 btrfs_item_offset_nr(leaf, slot))) 925 926 static inline struct dentry *fdentry(struct file *file) { 927 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18) 928 return file->f_dentry; 929 #else 930 return file->f_path.dentry; 931 #endif 932 } 933 934 /* extent-tree.c */ 935 u32 btrfs_count_snapshots_in_path(struct btrfs_root *root, 936 struct btrfs_path *count_path, 937 u64 first_extent); 938 int btrfs_extent_post_op(struct btrfs_trans_handle *trans, 939 struct btrfs_root *root); 940 int btrfs_copy_pinned(struct btrfs_root *root, struct extent_map_tree *copy); 941 struct btrfs_block_group_cache *btrfs_lookup_block_group(struct 942 btrfs_fs_info *info, 943 u64 bytenr); 944 struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root, 945 struct btrfs_block_group_cache 946 *hint, u64 search_start, 947 int data, int owner); 948 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans, 949 struct btrfs_root *root, u64 owner_objectid); 950 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 951 struct btrfs_root *root, u32 size, 952 u64 root_objectid, 953 u64 hint, u64 empty_size); 954 struct extent_buffer *__btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 955 struct btrfs_root *root, 956 u32 blocksize, 957 u64 root_objectid, 958 u64 ref_generation, 959 u64 first_objectid, 960 int level, 961 u64 hint, 962 u64 empty_size); 963 int btrfs_insert_extent_backref(struct btrfs_trans_handle *trans, 964 struct btrfs_root *root, 965 struct btrfs_path *path, u64 bytenr, 966 u64 root_objectid, u64 ref_generation, 967 u64 owner, u64 owner_offset); 968 int btrfs_alloc_extent(struct btrfs_trans_handle *trans, 969 struct btrfs_root *root, 970 u64 num_bytes, u64 root_objectid, u64 ref_generation, 971 u64 owner, u64 owner_offset, 972 u64 empty_size, u64 hint_byte, 973 u64 search_end, struct btrfs_key *ins, int data); 974 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, 975 struct extent_buffer *buf); 976 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root 977 *root, u64 bytenr, u64 num_bytes, 978 u64 root_objectid, u64 ref_generation, 979 u64 owner_objectid, u64 owner_offset, int pin); 980 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, 981 struct btrfs_root *root, 982 struct extent_map_tree *unpin); 983 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, 984 struct btrfs_root *root, 985 u64 bytenr, u64 num_bytes, 986 u64 root_objectid, u64 ref_generation, 987 u64 owner, u64 owner_offset); 988 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans, 989 struct btrfs_root *root); 990 int btrfs_free_block_groups(struct btrfs_fs_info *info); 991 int btrfs_read_block_groups(struct btrfs_root *root); 992 /* ctree.c */ 993 int btrfs_cow_block(struct btrfs_trans_handle *trans, 994 struct btrfs_root *root, struct extent_buffer *buf, 995 struct extent_buffer *parent, int parent_slot, 996 struct extent_buffer **cow_ret); 997 int btrfs_copy_root(struct btrfs_trans_handle *trans, 998 struct btrfs_root *root, 999 struct extent_buffer *buf, 1000 struct extent_buffer **cow_ret, u64 new_root_objectid); 1001 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root 1002 *root, struct btrfs_path *path, u32 data_size); 1003 int btrfs_truncate_item(struct btrfs_trans_handle *trans, 1004 struct btrfs_root *root, 1005 struct btrfs_path *path, 1006 u32 new_size, int from_end); 1007 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root 1008 *root, struct btrfs_key *key, struct btrfs_path *p, int 1009 ins_len, int cow); 1010 int btrfs_realloc_node(struct btrfs_trans_handle *trans, 1011 struct btrfs_root *root, struct extent_buffer *parent, 1012 int start_slot, int cache_only, u64 *last_ret, 1013 struct btrfs_key *progress); 1014 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p); 1015 struct btrfs_path *btrfs_alloc_path(void); 1016 void btrfs_free_path(struct btrfs_path *p); 1017 void btrfs_init_path(struct btrfs_path *p); 1018 int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 1019 struct btrfs_path *path); 1020 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root 1021 *root, struct btrfs_key *key, void *data, u32 data_size); 1022 int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root 1023 *root, struct btrfs_path *path, struct btrfs_key 1024 *cpu_key, u32 data_size); 1025 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path); 1026 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); 1027 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); 1028 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root 1029 *root); 1030 /* root-item.c */ 1031 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, 1032 struct btrfs_key *key); 1033 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root 1034 *root, struct btrfs_key *key, struct btrfs_root_item 1035 *item); 1036 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root 1037 *root, struct btrfs_key *key, struct btrfs_root_item 1038 *item); 1039 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct 1040 btrfs_root_item *item, struct btrfs_key *key); 1041 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid, 1042 struct btrfs_root *latest_root); 1043 /* dir-item.c */ 1044 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root 1045 *root, const char *name, int name_len, u64 dir, 1046 struct btrfs_key *location, u8 type); 1047 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, 1048 struct btrfs_root *root, 1049 struct btrfs_path *path, u64 dir, 1050 const char *name, int name_len, 1051 int mod); 1052 struct btrfs_dir_item * 1053 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans, 1054 struct btrfs_root *root, 1055 struct btrfs_path *path, u64 dir, 1056 u64 objectid, const char *name, int name_len, 1057 int mod); 1058 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root, 1059 struct btrfs_path *path, 1060 const char *name, int name_len); 1061 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, 1062 struct btrfs_root *root, 1063 struct btrfs_path *path, 1064 struct btrfs_dir_item *di); 1065 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, 1066 struct btrfs_root *root, const char *name, 1067 u16 name_len, const void *data, u16 data_len, 1068 u64 dir); 1069 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans, 1070 struct btrfs_root *root, 1071 struct btrfs_path *path, u64 dir, 1072 const char *name, u16 name_len, 1073 int mod); 1074 /* inode-map.c */ 1075 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans, 1076 struct btrfs_root *fs_root, 1077 u64 dirid, u64 *objectid); 1078 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid); 1079 1080 /* inode-item.c */ 1081 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, 1082 struct btrfs_root *root, 1083 const char *name, int name_len, 1084 u64 inode_objectid, u64 ref_objectid); 1085 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 1086 struct btrfs_root *root, 1087 const char *name, int name_len, 1088 u64 inode_objectid, u64 ref_objectid); 1089 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, 1090 struct btrfs_root *root, 1091 struct btrfs_path *path, u64 objectid); 1092 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root 1093 *root, struct btrfs_path *path, 1094 struct btrfs_key *location, int mod); 1095 1096 /* file-item.c */ 1097 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 1098 struct btrfs_root *root, 1099 u64 objectid, u64 pos, u64 offset, 1100 u64 disk_num_bytes, 1101 u64 num_bytes); 1102 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 1103 struct btrfs_root *root, 1104 struct btrfs_path *path, u64 objectid, 1105 u64 bytenr, int mod); 1106 int btrfs_csum_file_block(struct btrfs_trans_handle *trans, 1107 struct btrfs_root *root, 1108 struct inode *inode, 1109 u64 objectid, u64 offset, 1110 char *data, size_t len); 1111 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans, 1112 struct btrfs_root *root, 1113 struct btrfs_path *path, 1114 u64 objectid, u64 offset, 1115 int cow); 1116 int btrfs_csum_truncate(struct btrfs_trans_handle *trans, 1117 struct btrfs_root *root, struct btrfs_path *path, 1118 u64 isize); 1119 /* inode.c */ 1120 int btrfs_check_free_space(struct btrfs_root *root, u64 num_required, 1121 int for_del); 1122 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page); 1123 int btrfs_readpage(struct file *file, struct page *page); 1124 void btrfs_delete_inode(struct inode *inode); 1125 void btrfs_read_locked_inode(struct inode *inode); 1126 int btrfs_write_inode(struct inode *inode, int wait); 1127 void btrfs_dirty_inode(struct inode *inode); 1128 struct inode *btrfs_alloc_inode(struct super_block *sb); 1129 void btrfs_destroy_inode(struct inode *inode); 1130 int btrfs_init_cachep(void); 1131 void btrfs_destroy_cachep(void); 1132 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 1133 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid, 1134 struct btrfs_root *root); 1135 int btrfs_commit_write(struct file *file, struct page *page, 1136 unsigned from, unsigned to); 1137 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page, 1138 size_t page_offset, u64 start, u64 end, 1139 int create); 1140 int btrfs_update_inode(struct btrfs_trans_handle *trans, 1141 struct btrfs_root *root, 1142 struct inode *inode); 1143 /* file.c */ 1144 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end); 1145 extern struct file_operations btrfs_file_operations; 1146 int btrfs_drop_extents(struct btrfs_trans_handle *trans, 1147 struct btrfs_root *root, struct inode *inode, 1148 u64 start, u64 end, u64 inline_limit, u64 *hint_block); 1149 /* tree-defrag.c */ 1150 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans, 1151 struct btrfs_root *root, int cache_only); 1152 1153 /* sysfs.c */ 1154 int btrfs_init_sysfs(void); 1155 void btrfs_exit_sysfs(void); 1156 int btrfs_sysfs_add_super(struct btrfs_fs_info *fs); 1157 int btrfs_sysfs_add_root(struct btrfs_root *root); 1158 void btrfs_sysfs_del_root(struct btrfs_root *root); 1159 void btrfs_sysfs_del_super(struct btrfs_fs_info *root); 1160 1161 /* xattr.c */ 1162 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size); 1163 int btrfs_delete_xattrs(struct btrfs_trans_handle *trans, 1164 struct btrfs_root *root, struct inode *inode); 1165 #endif 1166