fs/btrfs/ctree.h

   1 #ifndef __BTRFS__
   2 #define __BTRFS__
   3
   4 #include "list.h"
   5 #include "kerncompat.h"
   6
   7 #define BTRFS_MAGIC "_BtRfS_M"
   8
   9 #define BTRFS_ROOT_TREE_OBJECTID 1
  10 #define BTRFS_EXTENT_TREE_OBJECTID 2
  11 #define BTRFS_FS_TREE_OBJECTID 3
  12
  13 /*
  14  * the key defines the order in the tree, and so it also defines (optimal)
  15  * block layout.  objectid corresonds to the inode number.  The flags
  16  * tells us things about the object, and is a kind of stream selector.
  17  * so for a given inode, keys with flags of 1 might refer to the inode
  18  * data, flags of 2 may point to file data in the btree and flags == 3
  19  * may point to extents.
  20  *
  21  * offset is the starting byte offset for this key in the stream.
  22  *
  23  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
  24  * in cpu native order.  Otherwise they are identical and their sizes
  25  * should be the same (ie both packed)
  26  */
  27 struct btrfs_disk_key {
  28         __le64 objectid;
  29         __le32 flags;
  30         __le64 offset;
  31 } __attribute__ ((__packed__));
  32
  33 struct btrfs_key {
  34         u64 objectid;
  35         u32 flags;
  36         u64 offset;
  37 } __attribute__ ((__packed__));
  38
  39 /*
  40  * every tree block (leaf or node) starts with this header.
  41  */
  42 struct btrfs_header {
  43         u8 fsid[16]; /* FS specific uuid */
  44         __le64 blocknr; /* which block this node is supposed to live in */
  45         __le64 parentid; /* objectid of the tree root */
  46         __le32 csum;
  47         __le32 ham;
  48         __le16 nritems;
  49         __le16 flags;
  50         /* generation flags to be added */
  51 } __attribute__ ((__packed__));
  52
  53 #define BTRFS_MAX_LEVEL 8
  54 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
  55                                 sizeof(struct btrfs_header)) / \
  56                                (sizeof(struct btrfs_disk_key) + sizeof(u64)))
  57 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
  58 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
  59
  60 struct btrfs_buffer;
  61 /*
  62  * the super block basically lists the main trees of the FS
  63  * it currently lacks any block count etc etc
  64  */
  65 struct btrfs_super_block {
  66         u8 fsid[16];    /* FS specific uuid */
  67         __le64 blocknr; /* this block number */
  68         __le32 csum;
  69         __le64 magic;
  70         __le32 blocksize;
  71         __le64 generation;
  72         __le64 root;
  73         __le64 total_blocks;
  74         __le64 blocks_used;
  75 } __attribute__ ((__packed__));
  76
  77 /*
  78  * A leaf is full of items. offset and size tell us where to find
  79  * the item in the leaf (relative to the start of the data area)
  80  */
  81 struct btrfs_item {
  82         struct btrfs_disk_key key;
  83         __le32 offset;
  84         __le16 size;
  85 } __attribute__ ((__packed__));
  86
  87 /*
  88  * leaves have an item area and a data area:
  89  * [item0, item1....itemN] [free space] [dataN...data1, data0]
  90  *
  91  * The data is separate from the items to get the keys closer together
  92  * during searches.
  93  */
  94 struct btrfs_leaf {
  95         struct btrfs_header header;
  96         struct btrfs_item items[];
  97 } __attribute__ ((__packed__));
  98
  99 /*
 100  * all non-leaf blocks are nodes, they hold only keys and pointers to
 101  * other blocks
 102  */
 103 struct btrfs_key_ptr {
 104         struct btrfs_disk_key key;
 105         __le64 blockptr;
 106 } __attribute__ ((__packed__));
 107
 108 struct btrfs_node {
 109         struct btrfs_header header;
 110         struct btrfs_key_ptr ptrs[];
 111 } __attribute__ ((__packed__));
 112
 113 /*
 114  * btrfs_paths remember the path taken from the root down to the leaf.
 115  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 116  * to any other levels that are present.
 117  *
 118  * The slots array records the index of the item or block pointer
 119  * used while walking the tree.
 120  */
 121 struct btrfs_path {
 122         struct btrfs_buffer *nodes[BTRFS_MAX_LEVEL];
 123         int slots[BTRFS_MAX_LEVEL];
 124 };
 125
 126 /*
 127  * items in the extent btree are used to record the objectid of the
 128  * owner of the block and the number of references
 129  */
 130 struct btrfs_extent_item {
 131         __le32 refs;
 132         __le64 owner;
 133 } __attribute__ ((__packed__));
 134
 135 struct btrfs_inode_timespec {
 136         __le32 sec;
 137         __le32 nsec;
 138 } __attribute__ ((__packed__));
 139
 140 /*
 141  * there is no padding here on purpose.  If you want to extent the inode,
 142  * make a new item type
 143  */
 144 struct btrfs_inode_item {
 145         __le64 generation;
 146         __le64 size;
 147         __le64 nblocks;
 148         __le32 nlink;
 149         __le32 uid;
 150         __le32 gid;
 151         __le32 mode;
 152         __le32 rdev;
 153         __le16 flags;
 154         __le16 compat_flags;
 155         struct btrfs_inode_timespec atime;
 156         struct btrfs_inode_timespec ctime;
 157         struct btrfs_inode_timespec mtime;
 158         struct btrfs_inode_timespec otime;
 159 } __attribute__ ((__packed__));
 160
 161 /* inline data is just a blob of bytes */
 162 struct btrfs_inline_data_item {
 163         u8 data;
 164 } __attribute__ ((__packed__));
 165
 166 struct btrfs_dir_item {
 167         __le64 objectid;
 168         __le16 flags;
 169         __le16 name_len;
 170         u8 type;
 171 } __attribute__ ((__packed__));
 172
 173 struct btrfs_root_item {
 174         __le64 blocknr;
 175         __le32 flags;
 176         __le64 block_limit;
 177         __le64 blocks_used;
 178         __le32 refs;
 179 };
 180
 181 /*
 182  * in ram representation of the tree.  extent_root is used for all allocations
 183  * and for the extent tree extent_root root.  current_insert is used
 184  * only for the extent tree.
 185  */
 186 struct btrfs_root {
 187         struct btrfs_buffer *node;
 188         struct btrfs_buffer *commit_root;
 189         struct btrfs_root *extent_root;
 190         struct btrfs_root *tree_root;
 191         struct btrfs_key current_insert;
 192         struct btrfs_key last_insert;
 193         int fp;
 194         struct radix_tree_root cache_radix;
 195         struct radix_tree_root pinned_radix;
 196         struct list_head trans;
 197         struct list_head cache;
 198         int cache_size;
 199         int ref_cows;
 200         struct btrfs_root_item root_item;
 201         struct btrfs_key root_key;
 202         u32 blocksize;
 203 };
 204
 205 /* the lower bits in the key flags defines the item type */
 206 #define BTRFS_KEY_TYPE_MAX      256
 207 #define BTRFS_KEY_TYPE_MASK     (BTRFS_KEY_TYPE_MAX - 1)
 208
 209 /*
 210  * inode items have the data typically returned from stat and store other
 211  * info about object characteristics.  There is one for every file and dir in
 212  * the FS
 213  */
 214 #define BTRFS_INODE_ITEM_KEY    1
 215
 216 /*
 217  * dir items are the name -> inode pointers in a directory.  There is one
 218  * for every name in a directory.
 219  */
 220 #define BTRFS_DIR_ITEM_KEY      2
 221 /*
 222  * inline data is file data that fits in the btree.
 223  */
 224 #define BTRFS_INLINE_DATA_KEY   3
 225 /*
 226  * extent data is for data that can't fit in the btree.  It points to
 227  * a (hopefully) huge chunk of disk
 228  */
 229 #define BTRFS_EXTENT_DATA_KEY   4
 230 /*
 231  * root items point to tree roots.  There are typically in the root
 232  * tree used by the super block to find all the other trees
 233  */
 234 #define BTRFS_ROOT_ITEM_KEY     5
 235 /*
 236  * extent items are in the extent map tree.  These record which blocks
 237  * are used, and how many references there are to each block
 238  */
 239 #define BTRFS_EXTENT_ITEM_KEY   6
 240 /*
 241  * string items are for debugging.  They just store a short string of
 242  * data in the FS
 243  */
 244 #define BTRFS_STRING_ITEM_KEY   7
 245
 246 static inline u64 btrfs_inode_generation(struct btrfs_inode_item *i)
 247 {
 248         return le64_to_cpu(i->generation);
 249 }
 250
 251 static inline void btrfs_set_inode_generation(struct btrfs_inode_item *i,
 252                                               u64 val)
 253 {
 254         i->generation = cpu_to_le64(val);
 255 }
 256
 257 static inline u64 btrfs_inode_size(struct btrfs_inode_item *i)
 258 {
 259         return le64_to_cpu(i->size);
 260 }
 261
 262 static inline void btrfs_set_inode_size(struct btrfs_inode_item *i, u64 val)
 263 {
 264         i->size = cpu_to_le64(val);
 265 }
 266
 267 static inline u64 btrfs_inode_nblocks(struct btrfs_inode_item *i)
 268 {
 269         return le64_to_cpu(i->nblocks);
 270 }
 271
 272 static inline void btrfs_set_inode_nblocks(struct btrfs_inode_item *i, u64 val)
 273 {
 274         i->nblocks = cpu_to_le64(val);
 275 }
 276
 277 static inline u32 btrfs_inode_nlink(struct btrfs_inode_item *i)
 278 {
 279         return le32_to_cpu(i->nlink);
 280 }
 281
 282 static inline void btrfs_set_inode_nlink(struct btrfs_inode_item *i, u32 val)
 283 {
 284         i->nlink = cpu_to_le32(val);
 285 }
 286
 287 static inline u32 btrfs_inode_uid(struct btrfs_inode_item *i)
 288 {
 289         return le32_to_cpu(i->uid);
 290 }
 291
 292 static inline void btrfs_set_inode_uid(struct btrfs_inode_item *i, u32 val)
 293 {
 294         i->uid = cpu_to_le32(val);
 295 }
 296
 297 static inline u32 btrfs_inode_gid(struct btrfs_inode_item *i)
 298 {
 299         return le32_to_cpu(i->gid);
 300 }
 301
 302 static inline void btrfs_set_inode_gid(struct btrfs_inode_item *i, u32 val)
 303 {
 304         i->gid = cpu_to_le32(val);
 305 }
 306
 307 static inline u32 btrfs_inode_mode(struct btrfs_inode_item *i)
 308 {
 309         return le32_to_cpu(i->mode);
 310 }
 311
 312 static inline void btrfs_set_inode_mode(struct btrfs_inode_item *i, u32 val)
 313 {
 314         i->mode = cpu_to_le32(val);
 315 }
 316
 317 static inline u32 btrfs_inode_rdev(struct btrfs_inode_item *i)
 318 {
 319         return le32_to_cpu(i->rdev);
 320 }
 321
 322 static inline void btrfs_set_inode_rdev(struct btrfs_inode_item *i, u32 val)
 323 {
 324         i->rdev = cpu_to_le32(val);
 325 }
 326
 327 static inline u16 btrfs_inode_flags(struct btrfs_inode_item *i)
 328 {
 329         return le16_to_cpu(i->flags);
 330 }
 331
 332 static inline void btrfs_set_inode_flags(struct btrfs_inode_item *i, u16 val)
 333 {
 334         i->flags = cpu_to_le16(val);
 335 }
 336
 337 static inline u16 btrfs_inode_compat_flags(struct btrfs_inode_item *i)
 338 {
 339         return le16_to_cpu(i->compat_flags);
 340 }
 341
 342 static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
 343                                                 u16 val)
 344 {
 345         i->compat_flags = cpu_to_le16(val);
 346 }
 347
 348
 349 static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
 350 {
 351         return le64_to_cpu(ei->owner);
 352 }
 353
 354 static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
 355 {
 356         ei->owner = cpu_to_le64(val);
 357 }
 358
 359 static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
 360 {
 361         return le32_to_cpu(ei->refs);
 362 }
 363
 364 static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
 365 {
 366         ei->refs = cpu_to_le32(val);
 367 }
 368
 369 static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
 370 {
 371         return le64_to_cpu(n->ptrs[nr].blockptr);
 372 }
 373
 374 static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
 375                                            u64 val)
 376 {
 377         n->ptrs[nr].blockptr = cpu_to_le64(val);
 378 }
 379
 380 static inline u32 btrfs_item_offset(struct btrfs_item *item)
 381 {
 382         return le32_to_cpu(item->offset);
 383 }
 384
 385 static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
 386 {
 387         item->offset = cpu_to_le32(val);
 388 }
 389
 390 static inline u32 btrfs_item_end(struct btrfs_item *item)
 391 {
 392         return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
 393 }
 394
 395 static inline u16 btrfs_item_size(struct btrfs_item *item)
 396 {
 397         return le16_to_cpu(item->size);
 398 }
 399
 400 static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
 401 {
 402         item->size = cpu_to_le16(val);
 403 }
 404
 405 static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
 406 {
 407         return le64_to_cpu(d->objectid);
 408 }
 409
 410 static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
 411 {
 412         d->objectid = cpu_to_le64(val);
 413 }
 414
 415 static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
 416 {
 417         return le16_to_cpu(d->flags);
 418 }
 419
 420 static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
 421 {
 422         d->flags = cpu_to_le16(val);
 423 }
 424
 425 static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
 426 {
 427         return d->type;
 428 }
 429
 430 static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
 431 {
 432         d->type = val;
 433 }
 434
 435 static inline u16 btrfs_dir_name_len(struct btrfs_dir_item *d)
 436 {
 437         return le16_to_cpu(d->name_len);
 438 }
 439
 440 static inline void btrfs_set_dir_name_len(struct btrfs_dir_item *d, u16 val)
 441 {
 442         d->name_len = cpu_to_le16(val);
 443 }
 444
 445 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 446                                          struct btrfs_disk_key *disk)
 447 {
 448         cpu->offset = le64_to_cpu(disk->offset);
 449         cpu->flags = le32_to_cpu(disk->flags);
 450         cpu->objectid = le64_to_cpu(disk->objectid);
 451 }
 452
 453 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
 454                                          struct btrfs_key *cpu)
 455 {
 456         disk->offset = cpu_to_le64(cpu->offset);
 457         disk->flags = cpu_to_le32(cpu->flags);
 458         disk->objectid = cpu_to_le64(cpu->objectid);
 459 }
 460
 461 static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
 462 {
 463         return le64_to_cpu(disk->objectid);
 464 }
 465
 466 static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
 467                                                u64 val)
 468 {
 469         disk->objectid = cpu_to_le64(val);
 470 }
 471
 472 static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
 473 {
 474         return le64_to_cpu(disk->offset);
 475 }
 476
 477 static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
 478                                              u64 val)
 479 {
 480         disk->offset = cpu_to_le64(val);
 481 }
 482
 483 static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
 484 {
 485         return le32_to_cpu(disk->flags);
 486 }
 487
 488 static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
 489                                             u32 val)
 490 {
 491         disk->flags = cpu_to_le32(val);
 492 }
 493
 494 static inline u32 btrfs_key_type(struct btrfs_key *key)
 495 {
 496         return key->flags & BTRFS_KEY_TYPE_MASK;
 497 }
 498
 499 static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
 500 {
 501         return le32_to_cpu(key->flags) & BTRFS_KEY_TYPE_MASK;
 502 }
 503
 504 static inline void btrfs_set_key_type(struct btrfs_key *key, u32 type)
 505 {
 506         BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
 507         key->flags = (key->flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
 508 }
 509
 510 static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key, u32 type)
 511 {
 512         u32 flags = btrfs_disk_key_flags(key);
 513         BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
 514         flags = (flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
 515         btrfs_set_disk_key_flags(key, flags);
 516 }
 517
 518 static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
 519 {
 520         return le64_to_cpu(h->blocknr);
 521 }
 522
 523 static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
 524 {
 525         h->blocknr = cpu_to_le64(blocknr);
 526 }
 527
 528 static inline u64 btrfs_header_parentid(struct btrfs_header *h)
 529 {
 530         return le64_to_cpu(h->parentid);
 531 }
 532
 533 static inline void btrfs_set_header_parentid(struct btrfs_header *h,
 534                                              u64 parentid)
 535 {
 536         h->parentid = cpu_to_le64(parentid);
 537 }
 538
 539 static inline u16 btrfs_header_nritems(struct btrfs_header *h)
 540 {
 541         return le16_to_cpu(h->nritems);
 542 }
 543
 544 static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
 545 {
 546         h->nritems = cpu_to_le16(val);
 547 }
 548
 549 static inline u16 btrfs_header_flags(struct btrfs_header *h)
 550 {
 551         return le16_to_cpu(h->flags);
 552 }
 553
 554 static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
 555 {
 556         h->flags = cpu_to_le16(val);
 557 }
 558
 559 static inline int btrfs_header_level(struct btrfs_header *h)
 560 {
 561         return btrfs_header_flags(h) & (BTRFS_MAX_LEVEL - 1);
 562 }
 563
 564 static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
 565 {
 566         u16 flags;
 567         BUG_ON(level > BTRFS_MAX_LEVEL);
 568         flags = btrfs_header_flags(h) & ~(BTRFS_MAX_LEVEL - 1);
 569         btrfs_set_header_flags(h, flags | level);
 570 }
 571
 572 static inline int btrfs_is_leaf(struct btrfs_node *n)
 573 {
 574         return (btrfs_header_level(&n->header) == 0);
 575 }
 576
 577 static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
 578 {
 579         return le64_to_cpu(item->blocknr);
 580 }
 581
 582 static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
 583 {
 584         item->blocknr = cpu_to_le64(val);
 585 }
 586
 587 static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
 588 {
 589         return le32_to_cpu(item->refs);
 590 }
 591
 592 static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
 593 {
 594         item->refs = cpu_to_le32(val);
 595 }
 596
 597 static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
 598 {
 599         return le64_to_cpu(s->blocknr);
 600 }
 601
 602 static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
 603 {
 604         s->blocknr = cpu_to_le64(val);
 605 }
 606
 607 static inline u64 btrfs_super_root(struct btrfs_super_block *s)
 608 {
 609         return le64_to_cpu(s->root);
 610 }
 611
 612 static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
 613 {
 614         s->root = cpu_to_le64(val);
 615 }
 616
 617 static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
 618 {
 619         return le64_to_cpu(s->total_blocks);
 620 }
 621
 622 static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
 623                                                 u64 val)
 624 {
 625         s->total_blocks = cpu_to_le64(val);
 626 }
 627
 628 static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
 629 {
 630         return le64_to_cpu(s->blocks_used);
 631 }
 632
 633 static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
 634                                                 u64 val)
 635 {
 636         s->blocks_used = cpu_to_le64(val);
 637 }
 638
 639 static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
 640 {
 641         return le32_to_cpu(s->blocksize);
 642 }
 643
 644 static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
 645                                                 u32 val)
 646 {
 647         s->blocksize = cpu_to_le32(val);
 648 }
 649
 650 static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
 651 {
 652         return (u8 *)l->items;
 653 }
 654 /* helper function to cast into the data area of the leaf. */
 655 #define btrfs_item_ptr(leaf, slot, type) \
 656         ((type *)(btrfs_leaf_data(leaf) + \
 657         btrfs_item_offset((leaf)->items + (slot))))
 658
 659 struct btrfs_buffer *btrfs_alloc_free_block(struct btrfs_root *root);
 660 int btrfs_inc_ref(struct btrfs_root *root, struct btrfs_buffer *buf);
 661 int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks);
 662 int btrfs_search_slot(struct btrfs_root *root, struct btrfs_key *key,
 663                 struct btrfs_path *p, int ins_len, int cow);
 664 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
 665 void btrfs_init_path(struct btrfs_path *p);
 666 int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
 667 int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
 668                 void *data, u32 data_size);
 669 int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
 670                             struct btrfs_key *cpu_key, u32 data_size);
 671 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
 672 int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
 673 int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);
 674 int btrfs_finish_extent_commit(struct btrfs_root *root);
 675 int btrfs_del_root(struct btrfs_root *root, struct btrfs_key *key);
 676 int btrfs_insert_root(struct btrfs_root *root, struct btrfs_key *key,
 677                       struct btrfs_root_item *item);
 678 int btrfs_update_root(struct btrfs_root *root, struct btrfs_key *key,
 679                       struct btrfs_root_item *item);
 680 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
 681                         struct btrfs_root_item *item, struct btrfs_key *key);
 682 int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
 683                           u64 dir, u64 objectid, u8 type);
 684 int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
 685                           u64 dir, char *name, int name_len, int mod);
 686 int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
 687                               char *name, int name_len);
 688 #endif