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