]> git.karo-electronics.de Git - karo-tx-linux.git/blob - fs/btrfs/ctree.h
Btrfs: rework csums and extent item ordering
[karo-tx-linux.git] / fs / btrfs / ctree.h
1 #ifndef __BTRFS__
2 #define __BTRFS__
3
4 #include <linux/fs.h>
5 #include <linux/buffer_head.h>
6 #include <linux/kobject.h>
7 #include "bit-radix.h"
8
9 struct btrfs_trans_handle;
10 struct btrfs_transaction;
11 extern struct kmem_cache *btrfs_path_cachep;
12
13 #define BTRFS_MAGIC "_BtRfS_M"
14
15 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
16 #define BTRFS_DEV_TREE_OBJECTID 2ULL
17 #define BTRFS_EXTENT_TREE_OBJECTID 3ULL
18 #define BTRFS_FS_TREE_OBJECTID 4ULL
19 #define BTRFS_ROOT_TREE_DIR_OBJECTID 5ULL
20 #define BTRFS_FIRST_FREE_OBJECTID 6ULL
21
22 /*
23  * we can actually store much bigger names, but lets not confuse the rest
24  * of linux
25  */
26 #define BTRFS_NAME_LEN 255
27
28 /* 32 bytes in various csum fields */
29 #define BTRFS_CSUM_SIZE 32
30
31 /*
32  * the key defines the order in the tree, and so it also defines (optimal)
33  * block layout.  objectid corresonds to the inode number.  The flags
34  * tells us things about the object, and is a kind of stream selector.
35  * so for a given inode, keys with flags of 1 might refer to the inode
36  * data, flags of 2 may point to file data in the btree and flags == 3
37  * may point to extents.
38  *
39  * offset is the starting byte offset for this key in the stream.
40  *
41  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
42  * in cpu native order.  Otherwise they are identical and their sizes
43  * should be the same (ie both packed)
44  */
45 struct btrfs_disk_key {
46         __le64 objectid;
47         __le32 flags;
48         __le64 offset;
49 } __attribute__ ((__packed__));
50
51 struct btrfs_key {
52         u64 objectid;
53         u32 flags;
54         u64 offset;
55 } __attribute__ ((__packed__));
56
57 /*
58  * every tree block (leaf or node) starts with this header.
59  */
60 struct btrfs_header {
61         u8 csum[BTRFS_CSUM_SIZE];
62         u8 fsid[16]; /* FS specific uuid */
63         __le64 blocknr; /* which block this node is supposed to live in */
64         __le64 generation;
65         __le16 nritems;
66         __le16 flags;
67         u8 level;
68 } __attribute__ ((__packed__));
69
70 #define BTRFS_MAX_LEVEL 8
71 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
72                                 sizeof(struct btrfs_header)) / \
73                                (sizeof(struct btrfs_disk_key) + sizeof(u64)))
74 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
75 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
76
77 struct buffer_head;
78 /*
79  * the super block basically lists the main trees of the FS
80  * it currently lacks any block count etc etc
81  */
82 struct btrfs_super_block {
83         u8 csum[BTRFS_CSUM_SIZE];
84         /* the first 3 fields must match struct btrfs_header */
85         u8 fsid[16];    /* FS specific uuid */
86         __le64 blocknr; /* this block number */
87         __le64 magic;
88         __le32 blocksize;
89         __le64 generation;
90         __le64 root;
91         __le64 total_blocks;
92         __le64 blocks_used;
93         __le64 root_dir_objectid;
94         __le64 last_device_id;
95         /* fields below here vary with the underlying disk */
96         __le64 device_block_start;
97         __le64 device_num_blocks;
98         __le64 device_root;
99         __le64 device_id;
100 } __attribute__ ((__packed__));
101
102 /*
103  * A leaf is full of items. offset and size tell us where to find
104  * the item in the leaf (relative to the start of the data area)
105  */
106 struct btrfs_item {
107         struct btrfs_disk_key key;
108         __le32 offset;
109         __le16 size;
110 } __attribute__ ((__packed__));
111
112 /*
113  * leaves have an item area and a data area:
114  * [item0, item1....itemN] [free space] [dataN...data1, data0]
115  *
116  * The data is separate from the items to get the keys closer together
117  * during searches.
118  */
119 struct btrfs_leaf {
120         struct btrfs_header header;
121         struct btrfs_item items[];
122 } __attribute__ ((__packed__));
123
124 /*
125  * all non-leaf blocks are nodes, they hold only keys and pointers to
126  * other blocks
127  */
128 struct btrfs_key_ptr {
129         struct btrfs_disk_key key;
130         __le64 blockptr;
131 } __attribute__ ((__packed__));
132
133 struct btrfs_node {
134         struct btrfs_header header;
135         struct btrfs_key_ptr ptrs[];
136 } __attribute__ ((__packed__));
137
138 /*
139  * btrfs_paths remember the path taken from the root down to the leaf.
140  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
141  * to any other levels that are present.
142  *
143  * The slots array records the index of the item or block pointer
144  * used while walking the tree.
145  */
146 struct btrfs_path {
147         struct buffer_head *nodes[BTRFS_MAX_LEVEL];
148         int slots[BTRFS_MAX_LEVEL];
149 };
150
151 /*
152  * items in the extent btree are used to record the objectid of the
153  * owner of the block and the number of references
154  */
155 struct btrfs_extent_item {
156         __le32 refs;
157 } __attribute__ ((__packed__));
158
159 struct btrfs_inode_timespec {
160         __le64 sec;
161         __le32 nsec;
162 } __attribute__ ((__packed__));
163
164 /*
165  * there is no padding here on purpose.  If you want to extent the inode,
166  * make a new item type
167  */
168 struct btrfs_inode_item {
169         __le64 generation;
170         __le64 size;
171         __le64 nblocks;
172         __le32 nlink;
173         __le32 uid;
174         __le32 gid;
175         __le32 mode;
176         __le32 rdev;
177         __le16 flags;
178         __le16 compat_flags;
179         struct btrfs_inode_timespec atime;
180         struct btrfs_inode_timespec ctime;
181         struct btrfs_inode_timespec mtime;
182         struct btrfs_inode_timespec otime;
183 } __attribute__ ((__packed__));
184
185 /* inline data is just a blob of bytes */
186 struct btrfs_inline_data_item {
187         u8 data;
188 } __attribute__ ((__packed__));
189
190 struct btrfs_dir_item {
191         struct btrfs_disk_key location;
192         __le16 flags;
193         __le16 name_len;
194         u8 type;
195 } __attribute__ ((__packed__));
196
197 struct btrfs_root_item {
198         struct btrfs_inode_item inode;
199         __le64 root_dirid;
200         __le64 blocknr;
201         __le32 flags;
202         __le64 block_limit;
203         __le64 blocks_used;
204         __le32 refs;
205 } __attribute__ ((__packed__));
206
207 struct btrfs_file_extent_item {
208         __le64 generation;
209         /*
210          * disk space consumed by the extent, checksum blocks are included
211          * in these numbers
212          */
213         __le64 disk_blocknr;
214         __le64 disk_num_blocks;
215         /*
216          * the logical offset in file blocks (no csums)
217          * this extent record is for.  This allows a file extent to point
218          * into the middle of an existing extent on disk, sharing it
219          * between two snapshots (useful if some bytes in the middle of the
220          * extent have changed
221          */
222         __le64 offset;
223         /*
224          * the logical number of file blocks (no csums included)
225          */
226         __le64 num_blocks;
227 } __attribute__ ((__packed__));
228
229 struct btrfs_csum_item {
230         u8 csum[BTRFS_CSUM_SIZE];
231 } __attribute__ ((__packed__));
232
233 struct btrfs_device_item {
234         __le16 pathlen;
235         __le64 device_id;
236 } __attribute__ ((__packed__));
237
238 struct crypto_hash;
239 struct btrfs_fs_info {
240         struct btrfs_root *extent_root;
241         struct btrfs_root *tree_root;
242         struct btrfs_root *dev_root;
243         struct btrfs_key current_insert;
244         struct btrfs_key last_insert;
245         struct radix_tree_root fs_roots_radix;
246         struct radix_tree_root pending_del_radix;
247         struct radix_tree_root pinned_radix;
248         struct radix_tree_root dev_radix;
249         u64 generation;
250         struct btrfs_transaction *running_transaction;
251         struct btrfs_super_block *disk_super;
252         struct buffer_head *sb_buffer;
253         struct super_block *sb;
254         struct inode *btree_inode;
255         struct mutex trans_mutex;
256         struct mutex fs_mutex;
257         struct crypto_hash *hash_tfm;
258         spinlock_t hash_lock;
259         struct kobject kobj;
260 };
261
262 /*
263  * in ram representation of the tree.  extent_root is used for all allocations
264  * and for the extent tree extent_root root.  current_insert is used
265  * only for the extent tree.
266  */
267 struct btrfs_root {
268         struct buffer_head *node;
269         struct buffer_head *commit_root;
270         struct btrfs_root_item root_item;
271         struct btrfs_key root_key;
272         struct btrfs_fs_info *fs_info;
273         struct inode *inode;
274         u64 objectid;
275         u64 last_trans;
276         u32 blocksize;
277         int ref_cows;
278         u32 type;
279         u64 highest_inode;
280         u64 last_inode_alloc;
281 };
282
283 /* the lower bits in the key flags defines the item type */
284 #define BTRFS_KEY_TYPE_MAX      256
285 #define BTRFS_KEY_TYPE_MASK     (BTRFS_KEY_TYPE_MAX - 1)
286
287 #define BTRFS_KEY_OVERFLOW_MAX 128
288 #define BTRFS_KEY_OVERFLOW_SHIFT 8
289 #define BTRFS_KEY_OVERFLOW_MASK (0x7FULL << BTRFS_KEY_OVERFLOW_SHIFT)
290
291 /*
292  * inode items have the data typically returned from stat and store other
293  * info about object characteristics.  There is one for every file and dir in
294  * the FS
295  */
296 #define BTRFS_INODE_ITEM_KEY    1
297
298 /*
299  * dir items are the name -> inode pointers in a directory.  There is one
300  * for every name in a directory.
301  */
302 #define BTRFS_DIR_ITEM_KEY      2
303 #define BTRFS_DIR_INDEX_KEY     3
304 /*
305  * inline data is file data that fits in the btree.
306  */
307 #define BTRFS_INLINE_DATA_KEY   4
308 /*
309  * extent data is for data that can't fit in the btree.  It points to
310  * a (hopefully) huge chunk of disk
311  */
312 #define BTRFS_EXTENT_DATA_KEY   5
313 /*
314  * csum items have the checksums for data in the extents
315  */
316 #define BTRFS_CSUM_ITEM_KEY     6
317
318 /*
319  * root items point to tree roots.  There are typically in the root
320  * tree used by the super block to find all the other trees
321  */
322 #define BTRFS_ROOT_ITEM_KEY     7
323 /*
324  * extent items are in the extent map tree.  These record which blocks
325  * are used, and how many references there are to each block
326  */
327 #define BTRFS_EXTENT_ITEM_KEY   8
328
329 /*
330  * dev items list the devices that make up the FS
331  */
332 #define BTRFS_DEV_ITEM_KEY      9
333
334 /*
335  * string items are for debugging.  They just store a short string of
336  * data in the FS
337  */
338 #define BTRFS_STRING_ITEM_KEY   10
339
340 static inline u64 btrfs_inode_generation(struct btrfs_inode_item *i)
341 {
342         return le64_to_cpu(i->generation);
343 }
344
345 static inline void btrfs_set_inode_generation(struct btrfs_inode_item *i,
346                                               u64 val)
347 {
348         i->generation = cpu_to_le64(val);
349 }
350
351 static inline u64 btrfs_inode_size(struct btrfs_inode_item *i)
352 {
353         return le64_to_cpu(i->size);
354 }
355
356 static inline void btrfs_set_inode_size(struct btrfs_inode_item *i, u64 val)
357 {
358         i->size = cpu_to_le64(val);
359 }
360
361 static inline u64 btrfs_inode_nblocks(struct btrfs_inode_item *i)
362 {
363         return le64_to_cpu(i->nblocks);
364 }
365
366 static inline void btrfs_set_inode_nblocks(struct btrfs_inode_item *i, u64 val)
367 {
368         i->nblocks = cpu_to_le64(val);
369 }
370
371 static inline u32 btrfs_inode_nlink(struct btrfs_inode_item *i)
372 {
373         return le32_to_cpu(i->nlink);
374 }
375
376 static inline void btrfs_set_inode_nlink(struct btrfs_inode_item *i, u32 val)
377 {
378         i->nlink = cpu_to_le32(val);
379 }
380
381 static inline u32 btrfs_inode_uid(struct btrfs_inode_item *i)
382 {
383         return le32_to_cpu(i->uid);
384 }
385
386 static inline void btrfs_set_inode_uid(struct btrfs_inode_item *i, u32 val)
387 {
388         i->uid = cpu_to_le32(val);
389 }
390
391 static inline u32 btrfs_inode_gid(struct btrfs_inode_item *i)
392 {
393         return le32_to_cpu(i->gid);
394 }
395
396 static inline void btrfs_set_inode_gid(struct btrfs_inode_item *i, u32 val)
397 {
398         i->gid = cpu_to_le32(val);
399 }
400
401 static inline u32 btrfs_inode_mode(struct btrfs_inode_item *i)
402 {
403         return le32_to_cpu(i->mode);
404 }
405
406 static inline void btrfs_set_inode_mode(struct btrfs_inode_item *i, u32 val)
407 {
408         i->mode = cpu_to_le32(val);
409 }
410
411 static inline u32 btrfs_inode_rdev(struct btrfs_inode_item *i)
412 {
413         return le32_to_cpu(i->rdev);
414 }
415
416 static inline void btrfs_set_inode_rdev(struct btrfs_inode_item *i, u32 val)
417 {
418         i->rdev = cpu_to_le32(val);
419 }
420
421 static inline u16 btrfs_inode_flags(struct btrfs_inode_item *i)
422 {
423         return le16_to_cpu(i->flags);
424 }
425
426 static inline void btrfs_set_inode_flags(struct btrfs_inode_item *i, u16 val)
427 {
428         i->flags = cpu_to_le16(val);
429 }
430
431 static inline u16 btrfs_inode_compat_flags(struct btrfs_inode_item *i)
432 {
433         return le16_to_cpu(i->compat_flags);
434 }
435
436 static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
437                                                 u16 val)
438 {
439         i->compat_flags = cpu_to_le16(val);
440 }
441
442 static inline u64 btrfs_timespec_sec(struct btrfs_inode_timespec *ts)
443 {
444         return le64_to_cpu(ts->sec);
445 }
446
447 static inline void btrfs_set_timespec_sec(struct btrfs_inode_timespec *ts,
448                                           u64 val)
449 {
450         ts->sec = cpu_to_le64(val);
451 }
452
453 static inline u32 btrfs_timespec_nsec(struct btrfs_inode_timespec *ts)
454 {
455         return le32_to_cpu(ts->nsec);
456 }
457
458 static inline void btrfs_set_timespec_nsec(struct btrfs_inode_timespec *ts,
459                                           u32 val)
460 {
461         ts->nsec = cpu_to_le32(val);
462 }
463
464 static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
465 {
466         return le32_to_cpu(ei->refs);
467 }
468
469 static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
470 {
471         ei->refs = cpu_to_le32(val);
472 }
473
474 static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
475 {
476         return le64_to_cpu(n->ptrs[nr].blockptr);
477 }
478
479 static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
480                                            u64 val)
481 {
482         n->ptrs[nr].blockptr = cpu_to_le64(val);
483 }
484
485 static inline u32 btrfs_item_offset(struct btrfs_item *item)
486 {
487         return le32_to_cpu(item->offset);
488 }
489
490 static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
491 {
492         item->offset = cpu_to_le32(val);
493 }
494
495 static inline u32 btrfs_item_end(struct btrfs_item *item)
496 {
497         return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
498 }
499
500 static inline u16 btrfs_item_size(struct btrfs_item *item)
501 {
502         return le16_to_cpu(item->size);
503 }
504
505 static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
506 {
507         item->size = cpu_to_le16(val);
508 }
509
510 static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
511 {
512         return le16_to_cpu(d->flags);
513 }
514
515 static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
516 {
517         d->flags = cpu_to_le16(val);
518 }
519
520 static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
521 {
522         return d->type;
523 }
524
525 static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
526 {
527         d->type = val;
528 }
529
530 static inline u16 btrfs_dir_name_len(struct btrfs_dir_item *d)
531 {
532         return le16_to_cpu(d->name_len);
533 }
534
535 static inline void btrfs_set_dir_name_len(struct btrfs_dir_item *d, u16 val)
536 {
537         d->name_len = cpu_to_le16(val);
538 }
539
540 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
541                                          struct btrfs_disk_key *disk)
542 {
543         cpu->offset = le64_to_cpu(disk->offset);
544         cpu->flags = le32_to_cpu(disk->flags);
545         cpu->objectid = le64_to_cpu(disk->objectid);
546 }
547
548 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
549                                          struct btrfs_key *cpu)
550 {
551         disk->offset = cpu_to_le64(cpu->offset);
552         disk->flags = cpu_to_le32(cpu->flags);
553         disk->objectid = cpu_to_le64(cpu->objectid);
554 }
555
556 static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
557 {
558         return le64_to_cpu(disk->objectid);
559 }
560
561 static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
562                                                u64 val)
563 {
564         disk->objectid = cpu_to_le64(val);
565 }
566
567 static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
568 {
569         return le64_to_cpu(disk->offset);
570 }
571
572 static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
573                                              u64 val)
574 {
575         disk->offset = cpu_to_le64(val);
576 }
577
578 static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
579 {
580         return le32_to_cpu(disk->flags);
581 }
582
583 static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
584                                             u32 val)
585 {
586         disk->flags = cpu_to_le32(val);
587 }
588
589 static inline u32 btrfs_key_overflow(struct btrfs_key *key)
590 {
591         u32 over = key->flags & BTRFS_KEY_OVERFLOW_MASK;
592         return over >> BTRFS_KEY_OVERFLOW_SHIFT;
593 }
594
595 static inline void btrfs_set_key_overflow(struct btrfs_key *key, u32 over)
596 {
597         BUG_ON(over >= BTRFS_KEY_OVERFLOW_MAX);
598         over = over << BTRFS_KEY_OVERFLOW_SHIFT;
599         key->flags = (key->flags & ~((u64)BTRFS_KEY_OVERFLOW_MASK)) | over;
600 }
601
602 static inline u32 btrfs_key_type(struct btrfs_key *key)
603 {
604         return key->flags & BTRFS_KEY_TYPE_MASK;
605 }
606
607 static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
608 {
609         return le32_to_cpu(key->flags) & BTRFS_KEY_TYPE_MASK;
610 }
611
612 static inline void btrfs_set_key_type(struct btrfs_key *key, u32 type)
613 {
614         BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
615         key->flags = (key->flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
616 }
617
618 static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key, u32 type)
619 {
620         u32 flags = btrfs_disk_key_flags(key);
621         BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
622         flags = (flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
623         btrfs_set_disk_key_flags(key, flags);
624 }
625
626 static inline u32 btrfs_disk_key_overflow(struct btrfs_disk_key *key)
627 {
628         u32 over = le32_to_cpu(key->flags) & BTRFS_KEY_OVERFLOW_MASK;
629         return over >> BTRFS_KEY_OVERFLOW_SHIFT;
630 }
631
632 static inline void btrfs_set_disK_key_overflow(struct btrfs_disk_key *key,
633                                                u32 over)
634 {
635         u32 flags = btrfs_disk_key_flags(key);
636         BUG_ON(over >= BTRFS_KEY_OVERFLOW_MAX);
637         over = over << BTRFS_KEY_OVERFLOW_SHIFT;
638         flags = (flags & ~((u64)BTRFS_KEY_OVERFLOW_MASK)) | over;
639         btrfs_set_disk_key_flags(key, flags);
640 }
641
642 static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
643 {
644         return le64_to_cpu(h->blocknr);
645 }
646
647 static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
648 {
649         h->blocknr = cpu_to_le64(blocknr);
650 }
651
652 static inline u64 btrfs_header_generation(struct btrfs_header *h)
653 {
654         return le64_to_cpu(h->generation);
655 }
656
657 static inline void btrfs_set_header_generation(struct btrfs_header *h,
658                                                u64 val)
659 {
660         h->generation = cpu_to_le64(val);
661 }
662
663 static inline u16 btrfs_header_nritems(struct btrfs_header *h)
664 {
665         return le16_to_cpu(h->nritems);
666 }
667
668 static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
669 {
670         h->nritems = cpu_to_le16(val);
671 }
672
673 static inline u16 btrfs_header_flags(struct btrfs_header *h)
674 {
675         return le16_to_cpu(h->flags);
676 }
677
678 static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
679 {
680         h->flags = cpu_to_le16(val);
681 }
682
683 static inline int btrfs_header_level(struct btrfs_header *h)
684 {
685         return h->level;
686 }
687
688 static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
689 {
690         BUG_ON(level > BTRFS_MAX_LEVEL);
691         h->level = level;
692 }
693
694 static inline int btrfs_is_leaf(struct btrfs_node *n)
695 {
696         return (btrfs_header_level(&n->header) == 0);
697 }
698
699 static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
700 {
701         return le64_to_cpu(item->blocknr);
702 }
703
704 static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
705 {
706         item->blocknr = cpu_to_le64(val);
707 }
708
709 static inline u64 btrfs_root_dirid(struct btrfs_root_item *item)
710 {
711         return le64_to_cpu(item->root_dirid);
712 }
713
714 static inline void btrfs_set_root_dirid(struct btrfs_root_item *item, u64 val)
715 {
716         item->root_dirid = cpu_to_le64(val);
717 }
718
719 static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
720 {
721         return le32_to_cpu(item->refs);
722 }
723
724 static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
725 {
726         item->refs = cpu_to_le32(val);
727 }
728
729 static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
730 {
731         return le64_to_cpu(s->blocknr);
732 }
733
734 static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
735 {
736         s->blocknr = cpu_to_le64(val);
737 }
738
739 static inline u64 btrfs_super_generation(struct btrfs_super_block *s)
740 {
741         return le64_to_cpu(s->generation);
742 }
743
744 static inline void btrfs_set_super_generation(struct btrfs_super_block *s,
745                                               u64 val)
746 {
747         s->generation = cpu_to_le64(val);
748 }
749
750 static inline u64 btrfs_super_root(struct btrfs_super_block *s)
751 {
752         return le64_to_cpu(s->root);
753 }
754
755 static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
756 {
757         s->root = cpu_to_le64(val);
758 }
759
760 static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
761 {
762         return le64_to_cpu(s->total_blocks);
763 }
764
765 static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
766                                                 u64 val)
767 {
768         s->total_blocks = cpu_to_le64(val);
769 }
770
771 static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
772 {
773         return le64_to_cpu(s->blocks_used);
774 }
775
776 static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
777                                                 u64 val)
778 {
779         s->blocks_used = cpu_to_le64(val);
780 }
781
782 static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
783 {
784         return le32_to_cpu(s->blocksize);
785 }
786
787 static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
788                                                 u32 val)
789 {
790         s->blocksize = cpu_to_le32(val);
791 }
792
793 static inline u64 btrfs_super_root_dir(struct btrfs_super_block *s)
794 {
795         return le64_to_cpu(s->root_dir_objectid);
796 }
797
798 static inline void btrfs_set_super_root_dir(struct btrfs_super_block *s, u64
799                                             val)
800 {
801         s->root_dir_objectid = cpu_to_le64(val);
802 }
803
804 static inline u64 btrfs_super_last_device_id(struct btrfs_super_block *s)
805 {
806         return le64_to_cpu(s->last_device_id);
807 }
808
809 static inline void btrfs_set_super_last_device_id(struct btrfs_super_block *s,
810                                                   u64 val)
811 {
812         s->last_device_id = cpu_to_le64(val);
813 }
814
815 static inline u64 btrfs_super_device_id(struct btrfs_super_block *s)
816 {
817         return le64_to_cpu(s->device_id);
818 }
819
820 static inline void btrfs_set_super_device_id(struct btrfs_super_block *s,
821                                                   u64 val)
822 {
823         s->device_id = cpu_to_le64(val);
824 }
825
826 static inline u64 btrfs_super_device_block_start(struct btrfs_super_block *s)
827 {
828         return le64_to_cpu(s->device_block_start);
829 }
830
831 static inline void btrfs_set_super_device_block_start(struct btrfs_super_block
832                                                       *s, u64 val)
833 {
834         s->device_block_start = cpu_to_le64(val);
835 }
836
837 static inline u64 btrfs_super_device_num_blocks(struct btrfs_super_block *s)
838 {
839         return le64_to_cpu(s->device_num_blocks);
840 }
841
842 static inline void btrfs_set_super_device_num_blocks(struct btrfs_super_block
843                                                      *s, u64 val)
844 {
845         s->device_num_blocks = cpu_to_le64(val);
846 }
847
848 static inline u64 btrfs_super_device_root(struct btrfs_super_block *s)
849 {
850         return le64_to_cpu(s->device_root);
851 }
852
853 static inline void btrfs_set_super_device_root(struct btrfs_super_block
854                                                       *s, u64 val)
855 {
856         s->device_root = cpu_to_le64(val);
857 }
858
859
860 static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
861 {
862         return (u8 *)l->items;
863 }
864
865 static inline u64 btrfs_file_extent_disk_blocknr(struct btrfs_file_extent_item
866                                                  *e)
867 {
868         return le64_to_cpu(e->disk_blocknr);
869 }
870
871 static inline void btrfs_set_file_extent_disk_blocknr(struct
872                                                       btrfs_file_extent_item
873                                                       *e, u64 val)
874 {
875         e->disk_blocknr = cpu_to_le64(val);
876 }
877
878 static inline u64 btrfs_file_extent_generation(struct btrfs_file_extent_item *e)
879 {
880         return le64_to_cpu(e->generation);
881 }
882
883 static inline void btrfs_set_file_extent_generation(struct
884                                                     btrfs_file_extent_item *e,
885                                                     u64 val)
886 {
887         e->generation = cpu_to_le64(val);
888 }
889
890 static inline u64 btrfs_file_extent_disk_num_blocks(struct
891                                                     btrfs_file_extent_item *e)
892 {
893         return le64_to_cpu(e->disk_num_blocks);
894 }
895
896 static inline void btrfs_set_file_extent_disk_num_blocks(struct
897                                                          btrfs_file_extent_item
898                                                          *e, u64 val)
899 {
900         e->disk_num_blocks = cpu_to_le64(val);
901 }
902
903 static inline u64 btrfs_file_extent_offset(struct btrfs_file_extent_item *e)
904 {
905         return le64_to_cpu(e->offset);
906 }
907
908 static inline void btrfs_set_file_extent_offset(struct btrfs_file_extent_item
909                                                 *e, u64 val)
910 {
911         e->offset = cpu_to_le64(val);
912 }
913
914 static inline u64 btrfs_file_extent_num_blocks(struct btrfs_file_extent_item
915                                                *e)
916 {
917         return le64_to_cpu(e->num_blocks);
918 }
919
920 static inline void btrfs_set_file_extent_num_blocks(struct
921                                                     btrfs_file_extent_item *e,
922                                                     u64 val)
923 {
924         e->num_blocks = cpu_to_le64(val);
925 }
926
927 static inline u16 btrfs_device_pathlen(struct btrfs_device_item *d)
928 {
929         return le16_to_cpu(d->pathlen);
930 }
931
932 static inline void btrfs_set_device_pathlen(struct btrfs_device_item *d,
933                                                 u16 val)
934 {
935         d->pathlen = cpu_to_le16(val);
936 }
937
938 static inline u64 btrfs_device_id(struct btrfs_device_item *d)
939 {
940         return le64_to_cpu(d->device_id);
941 }
942
943 static inline void btrfs_set_device_id(struct btrfs_device_item *d,
944                                                 u64 val)
945 {
946         d->device_id = cpu_to_le64(val);
947 }
948
949 static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
950 {
951         return sb->s_fs_info;
952 }
953
954 static inline void btrfs_check_bounds(void *vptr, size_t len,
955                                      void *vcontainer, size_t container_len)
956 {
957         char *ptr = vptr;
958         char *container = vcontainer;
959         WARN_ON(ptr < container);
960         WARN_ON(ptr + len > container + container_len);
961 }
962
963 static inline void btrfs_memcpy(struct btrfs_root *root,
964                                 void *dst_block,
965                                 void *dst, const void *src, size_t nr)
966 {
967         btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
968         memcpy(dst, src, nr);
969 }
970
971 static inline void btrfs_memmove(struct btrfs_root *root,
972                                 void *dst_block,
973                                 void *dst, void *src, size_t nr)
974 {
975         btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
976         memmove(dst, src, nr);
977 }
978
979 static inline void btrfs_mark_buffer_dirty(struct buffer_head *bh)
980 {
981         WARN_ON(!atomic_read(&bh->b_count));
982         mark_buffer_dirty(bh);
983 }
984
985 /* helper function to cast into the data area of the leaf. */
986 #define btrfs_item_ptr(leaf, slot, type) \
987         ((type *)(btrfs_leaf_data(leaf) + \
988         btrfs_item_offset((leaf)->items + (slot))))
989
990 /* extent-tree.c */
991 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
992                        struct btrfs_root *root);
993 struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
994                                             struct btrfs_root *root);
995 int btrfs_alloc_extent(struct btrfs_trans_handle *trans, struct btrfs_root
996                         *root, u64 num_blocks, u64 search_start, u64
997                         search_end, struct btrfs_key *ins);
998 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
999                   struct buffer_head *buf);
1000 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
1001                       *root, u64 blocknr, u64 num_blocks, int pin);
1002 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, struct
1003                                btrfs_root *root);
1004 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1005                                 struct btrfs_root *root,
1006                                 u64 blocknr, u64 num_blocks);
1007 /* ctree.c */
1008 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
1009                       *root, struct btrfs_path *path, u32 data_size);
1010 int btrfs_truncate_item(struct btrfs_trans_handle *trans,
1011                         struct btrfs_root *root,
1012                         struct btrfs_path *path,
1013                         u32 new_size);
1014 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
1015                       *root, struct btrfs_key *key, struct btrfs_path *p, int
1016                       ins_len, int cow);
1017 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
1018 struct btrfs_path *btrfs_alloc_path(void);
1019 void btrfs_free_path(struct btrfs_path *p);
1020 void btrfs_init_path(struct btrfs_path *p);
1021 int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1022                    struct btrfs_path *path);
1023 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
1024                       *root, struct btrfs_key *key, void *data, u32 data_size);
1025 int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
1026                             *root, struct btrfs_path *path, struct btrfs_key
1027                             *cpu_key, u32 data_size);
1028 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
1029 int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
1030 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
1031                         *root, struct buffer_head *snap);
1032 /* root-item.c */
1033 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1034                    struct btrfs_key *key);
1035 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
1036                       *root, struct btrfs_key *key, struct btrfs_root_item
1037                       *item);
1038 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
1039                       *root, struct btrfs_key *key, struct btrfs_root_item
1040                       *item);
1041 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
1042                          btrfs_root_item *item, struct btrfs_key *key);
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 int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
1048                           *root, struct btrfs_path *path, u64 dir,
1049                           const char *name, int name_len, int mod);
1050 int btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
1051                                 struct btrfs_root *root,
1052                                 struct btrfs_path *path, u64 dir,
1053                                 u64 objectid, int mod);
1054 int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
1055                               const char *name, int name_len);
1056 /* inode-map.c */
1057 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
1058                              struct btrfs_root *fs_root,
1059                              u64 dirid, u64 *objectid);
1060 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
1061
1062 /* inode-item.c */
1063 int btrfs_insert_inode(struct btrfs_trans_handle *trans, struct btrfs_root
1064                        *root, u64 objectid, struct btrfs_inode_item
1065                        *inode_item);
1066 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
1067                        *root, struct btrfs_path *path,
1068                        struct btrfs_key *location, int mod);
1069
1070 /* file-item.c */
1071 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
1072                                struct btrfs_root *root,
1073                                u64 objectid, u64 pos, u64 offset,
1074                                u64 num_blocks);
1075 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
1076                              struct btrfs_root *root,
1077                              struct btrfs_path *path, u64 objectid,
1078                              u64 blocknr, int mod);
1079 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
1080                           struct btrfs_root *root,
1081                           u64 objectid, u64 offset,
1082                           char *data, size_t len);
1083 int btrfs_csum_verify_file_block(struct btrfs_root *root,
1084                                  u64 objectid, u64 offset,
1085                                  char *data, size_t len);
1086 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
1087                                           struct btrfs_root *root,
1088                                           struct btrfs_path *path,
1089                                           u64 objectid, u64 offset,
1090                                           int cow);
1091 /* super.c */
1092 extern struct subsystem btrfs_subsys;
1093
1094 #endif