← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/btrfs/ctree.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/btrfs/ctree.h
 
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/mm.h>
 
23
#include <linux/highmem.h>
 
24
#include <linux/fs.h>
 
25
#include <linux/rwsem.h>
 
26
#include <linux/completion.h>
 
27
#include <linux/backing-dev.h>
 
28
#include <linux/wait.h>
 
29
#include <linux/slab.h>
 
30
#include <linux/kobject.h>
 
31
#include <trace/events/btrfs.h>
 
32
#include <asm/kmap_types.h>
 
33
#include <linux/pagemap.h>
 
34
#include "extent_io.h"
 
35
#include "extent_map.h"
 
36
#include "async-thread.h"
 
37
#include "ioctl.h"
 
38
 
 
39
struct btrfs_trans_handle;
 
40
struct btrfs_transaction;
 
41
struct btrfs_pending_snapshot;
 
42
extern struct kmem_cache *btrfs_trans_handle_cachep;
 
43
extern struct kmem_cache *btrfs_transaction_cachep;
 
44
extern struct kmem_cache *btrfs_bit_radix_cachep;
 
45
extern struct kmem_cache *btrfs_path_cachep;
 
46
extern struct kmem_cache *btrfs_free_space_cachep;
 
47
struct btrfs_ordered_sum;
 
48
 
 
49
#define BTRFS_MAGIC "_BHRfS_M"
 
50
 
 
51
#define BTRFS_MAX_LEVEL 8
 
52
 
 
53
#define BTRFS_COMPAT_EXTENT_TREE_V0
 
54
 
 
55
/*
 
56
 * files bigger than this get some pre-flushing when they are added
 
57
 * to the ordered operations list.  That way we limit the total
 
58
 * work done by the commit
 
59
 */
 
60
#define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
 
61
 
 
62
/* holds pointers to all of the tree roots */
 
63
#define BTRFS_ROOT_TREE_OBJECTID 1ULL
 
64
 
 
65
/* stores information about which extents are in use, and reference counts */
 
66
#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
 
67
 
 
68
/*
 
69
 * chunk tree stores translations from logical -> physical block numbering
 
70
 * the super block points to the chunk tree
 
71
 */
 
72
#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
 
73
 
 
74
/*
 
75
 * stores information about which areas of a given device are in use.
 
76
 * one per device.  The tree of tree roots points to the device tree
 
77
 */
 
78
#define BTRFS_DEV_TREE_OBJECTID 4ULL
 
79
 
 
80
/* one per subvolume, storing files and directories */
 
81
#define BTRFS_FS_TREE_OBJECTID 5ULL
 
82
 
 
83
/* directory objectid inside the root tree */
 
84
#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
 
85
 
 
86
/* holds checksums of all the data extents */
 
87
#define BTRFS_CSUM_TREE_OBJECTID 7ULL
 
88
 
 
89
/* orhpan objectid for tracking unlinked/truncated files */
 
90
#define BTRFS_ORPHAN_OBJECTID -5ULL
 
91
 
 
92
/* does write ahead logging to speed up fsyncs */
 
93
#define BTRFS_TREE_LOG_OBJECTID -6ULL
 
94
#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
 
95
 
 
96
/* for space balancing */
 
97
#define BTRFS_TREE_RELOC_OBJECTID -8ULL
 
98
#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
 
99
 
 
100
/*
 
101
 * extent checksums all have this objectid
 
102
 * this allows them to share the logging tree
 
103
 * for fsyncs
 
104
 */
 
105
#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
 
106
 
 
107
/* For storing free space cache */
 
108
#define BTRFS_FREE_SPACE_OBJECTID -11ULL
 
109
 
 
110
/*
 
111
 * The inode number assigned to the special inode for sotring
 
112
 * free ino cache
 
113
 */
 
114
#define BTRFS_FREE_INO_OBJECTID -12ULL
 
115
 
 
116
/* dummy objectid represents multiple objectids */
 
117
#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
 
118
 
 
119
/*
 
120
 * All files have objectids in this range.
 
121
 */
 
122
#define BTRFS_FIRST_FREE_OBJECTID 256ULL
 
123
#define BTRFS_LAST_FREE_OBJECTID -256ULL
 
124
#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
 
125
 
 
126
 
 
127
/*
 
128
 * the device items go into the chunk tree.  The key is in the form
 
129
 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
 
130
 */
 
131
#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
 
132
 
 
133
#define BTRFS_BTREE_INODE_OBJECTID 1
 
134
 
 
135
#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
 
136
 
 
137
/*
 
138
 * we can actually store much bigger names, but lets not confuse the rest
 
139
 * of linux
 
140
 */
 
141
#define BTRFS_NAME_LEN 255
 
142
 
 
143
/* 32 bytes in various csum fields */
 
144
#define BTRFS_CSUM_SIZE 32
 
145
 
 
146
/* csum types */
 
147
#define BTRFS_CSUM_TYPE_CRC32   0
 
148
 
 
149
static int btrfs_csum_sizes[] = { 4, 0 };
 
150
 
 
151
/* four bytes for CRC32 */
 
152
#define BTRFS_EMPTY_DIR_SIZE 0
 
153
 
 
154
#define BTRFS_FT_UNKNOWN        0
 
155
#define BTRFS_FT_REG_FILE       1
 
156
#define BTRFS_FT_DIR            2
 
157
#define BTRFS_FT_CHRDEV         3
 
158
#define BTRFS_FT_BLKDEV         4
 
159
#define BTRFS_FT_FIFO           5
 
160
#define BTRFS_FT_SOCK           6
 
161
#define BTRFS_FT_SYMLINK        7
 
162
#define BTRFS_FT_XATTR          8
 
163
#define BTRFS_FT_MAX            9
 
164
 
 
165
/*
 
166
 * The key defines the order in the tree, and so it also defines (optimal)
 
167
 * block layout.
 
168
 *
 
169
 * objectid corresponds to the inode number.
 
170
 *
 
171
 * type tells us things about the object, and is a kind of stream selector.
 
172
 * so for a given inode, keys with type of 1 might refer to the inode data,
 
173
 * type of 2 may point to file data in the btree and type == 3 may point to
 
174
 * extents.
 
175
 *
 
176
 * offset is the starting byte offset for this key in the stream.
 
177
 *
 
178
 * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
 
179
 * in cpu native order.  Otherwise they are identical and their sizes
 
180
 * should be the same (ie both packed)
 
181
 */
 
182
struct btrfs_disk_key {
 
183
        __le64 objectid;
 
184
        u8 type;
 
185
        __le64 offset;
 
186
} __attribute__ ((__packed__));
 
187
 
 
188
struct btrfs_key {
 
189
        u64 objectid;
 
190
        u8 type;
 
191
        u64 offset;
 
192
} __attribute__ ((__packed__));
 
193
 
 
194
struct btrfs_mapping_tree {
 
195
        struct extent_map_tree map_tree;
 
196
};
 
197
 
 
198
struct btrfs_dev_item {
 
199
        /* the internal btrfs device id */
 
200
        __le64 devid;
 
201
 
 
202
        /* size of the device */
 
203
        __le64 total_bytes;
 
204
 
 
205
        /* bytes used */
 
206
        __le64 bytes_used;
 
207
 
 
208
        /* optimal io alignment for this device */
 
209
        __le32 io_align;
 
210
 
 
211
        /* optimal io width for this device */
 
212
        __le32 io_width;
 
213
 
 
214
        /* minimal io size for this device */
 
215
        __le32 sector_size;
 
216
 
 
217
        /* type and info about this device */
 
218
        __le64 type;
 
219
 
 
220
        /* expected generation for this device */
 
221
        __le64 generation;
 
222
 
 
223
        /*
 
224
         * starting byte of this partition on the device,
 
225
         * to allow for stripe alignment in the future
 
226
         */
 
227
        __le64 start_offset;
 
228
 
 
229
        /* grouping information for allocation decisions */
 
230
        __le32 dev_group;
 
231
 
 
232
        /* seek speed 0-100 where 100 is fastest */
 
233
        u8 seek_speed;
 
234
 
 
235
        /* bandwidth 0-100 where 100 is fastest */
 
236
        u8 bandwidth;
 
237
 
 
238
        /* btrfs generated uuid for this device */
 
239
        u8 uuid[BTRFS_UUID_SIZE];
 
240
 
 
241
        /* uuid of FS who owns this device */
 
242
        u8 fsid[BTRFS_UUID_SIZE];
 
243
} __attribute__ ((__packed__));
 
244
 
 
245
struct btrfs_stripe {
 
246
        __le64 devid;
 
247
        __le64 offset;
 
248
        u8 dev_uuid[BTRFS_UUID_SIZE];
 
249
} __attribute__ ((__packed__));
 
250
 
 
251
struct btrfs_chunk {
 
252
        /* size of this chunk in bytes */
 
253
        __le64 length;
 
254
 
 
255
        /* objectid of the root referencing this chunk */
 
256
        __le64 owner;
 
257
 
 
258
        __le64 stripe_len;
 
259
        __le64 type;
 
260
 
 
261
        /* optimal io alignment for this chunk */
 
262
        __le32 io_align;
 
263
 
 
264
        /* optimal io width for this chunk */
 
265
        __le32 io_width;
 
266
 
 
267
        /* minimal io size for this chunk */
 
268
        __le32 sector_size;
 
269
 
 
270
        /* 2^16 stripes is quite a lot, a second limit is the size of a single
 
271
         * item in the btree
 
272
         */
 
273
        __le16 num_stripes;
 
274
 
 
275
        /* sub stripes only matter for raid10 */
 
276
        __le16 sub_stripes;
 
277
        struct btrfs_stripe stripe;
 
278
        /* additional stripes go here */
 
279
} __attribute__ ((__packed__));
 
280
 
 
281
#define BTRFS_FREE_SPACE_EXTENT 1
 
282
#define BTRFS_FREE_SPACE_BITMAP 2
 
283
 
 
284
struct btrfs_free_space_entry {
 
285
        __le64 offset;
 
286
        __le64 bytes;
 
287
        u8 type;
 
288
} __attribute__ ((__packed__));
 
289
 
 
290
struct btrfs_free_space_header {
 
291
        struct btrfs_disk_key location;
 
292
        __le64 generation;
 
293
        __le64 num_entries;
 
294
        __le64 num_bitmaps;
 
295
} __attribute__ ((__packed__));
 
296
 
 
297
static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 
298
{
 
299
        BUG_ON(num_stripes == 0);
 
300
        return sizeof(struct btrfs_chunk) +
 
301
                sizeof(struct btrfs_stripe) * (num_stripes - 1);
 
302
}
 
303
 
 
304
#define BTRFS_HEADER_FLAG_WRITTEN       (1ULL << 0)
 
305
#define BTRFS_HEADER_FLAG_RELOC         (1ULL << 1)
 
306
 
 
307
/*
 
308
 * File system states
 
309
 */
 
310
 
 
311
/* Errors detected */
 
312
#define BTRFS_SUPER_FLAG_ERROR          (1ULL << 2)
 
313
 
 
314
#define BTRFS_SUPER_FLAG_SEEDING        (1ULL << 32)
 
315
#define BTRFS_SUPER_FLAG_METADUMP       (1ULL << 33)
 
316
 
 
317
#define BTRFS_BACKREF_REV_MAX           256
 
318
#define BTRFS_BACKREF_REV_SHIFT         56
 
319
#define BTRFS_BACKREF_REV_MASK          (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
 
320
                                         BTRFS_BACKREF_REV_SHIFT)
 
321
 
 
322
#define BTRFS_OLD_BACKREF_REV           0
 
323
#define BTRFS_MIXED_BACKREF_REV         1
 
324
 
 
325
/*
 
326
 * every tree block (leaf or node) starts with this header.
 
327
 */
 
328
struct btrfs_header {
 
329
        /* these first four must match the super block */
 
330
        u8 csum[BTRFS_CSUM_SIZE];
 
331
        u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 
332
        __le64 bytenr; /* which block this node is supposed to live in */
 
333
        __le64 flags;
 
334
 
 
335
        /* allowed to be different from the super from here on down */
 
336
        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 
337
        __le64 generation;
 
338
        __le64 owner;
 
339
        __le32 nritems;
 
340
        u8 level;
 
341
} __attribute__ ((__packed__));
 
342
 
 
343
#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
 
344
                                      sizeof(struct btrfs_header)) / \
 
345
                                     sizeof(struct btrfs_key_ptr))
 
346
#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 
347
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
 
348
#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 
349
                                        sizeof(struct btrfs_item) - \
 
350
                                        sizeof(struct btrfs_file_extent_item))
 
351
#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 
352
                                 sizeof(struct btrfs_item) -\
 
353
                                 sizeof(struct btrfs_dir_item))
 
354
 
 
355
 
 
356
/*
 
357
 * this is a very generous portion of the super block, giving us
 
358
 * room to translate 14 chunks with 3 stripes each.
 
359
 */
 
360
#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
 
361
#define BTRFS_LABEL_SIZE 256
 
362
 
 
363
/*
 
364
 * just in case we somehow lose the roots and are not able to mount,
 
365
 * we store an array of the roots from previous transactions
 
366
 * in the super.
 
367
 */
 
368
#define BTRFS_NUM_BACKUP_ROOTS 4
 
369
struct btrfs_root_backup {
 
370
        __le64 tree_root;
 
371
        __le64 tree_root_gen;
 
372
 
 
373
        __le64 chunk_root;
 
374
        __le64 chunk_root_gen;
 
375
 
 
376
        __le64 extent_root;
 
377
        __le64 extent_root_gen;
 
378
 
 
379
        __le64 fs_root;
 
380
        __le64 fs_root_gen;
 
381
 
 
382
        __le64 dev_root;
 
383
        __le64 dev_root_gen;
 
384
 
 
385
        __le64 csum_root;
 
386
        __le64 csum_root_gen;
 
387
 
 
388
        __le64 total_bytes;
 
389
        __le64 bytes_used;
 
390
        __le64 num_devices;
 
391
        /* future */
 
392
        __le64 unsed_64[4];
 
393
 
 
394
        u8 tree_root_level;
 
395
        u8 chunk_root_level;
 
396
        u8 extent_root_level;
 
397
        u8 fs_root_level;
 
398
        u8 dev_root_level;
 
399
        u8 csum_root_level;
 
400
        /* future and to align */
 
401
        u8 unused_8[10];
 
402
} __attribute__ ((__packed__));
 
403
 
 
404
/*
 
405
 * the super block basically lists the main trees of the FS
 
406
 * it currently lacks any block count etc etc
 
407
 */
 
408
struct btrfs_super_block {
 
409
        u8 csum[BTRFS_CSUM_SIZE];
 
410
        /* the first 4 fields must match struct btrfs_header */
 
411
        u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
 
412
        __le64 bytenr; /* this block number */
 
413
        __le64 flags;
 
414
 
 
415
        /* allowed to be different from the btrfs_header from here own down */
 
416
        __le64 magic;
 
417
        __le64 generation;
 
418
        __le64 root;
 
419
        __le64 chunk_root;
 
420
        __le64 log_root;
 
421
 
 
422
        /* this will help find the new super based on the log root */
 
423
        __le64 log_root_transid;
 
424
        __le64 total_bytes;
 
425
        __le64 bytes_used;
 
426
        __le64 root_dir_objectid;
 
427
        __le64 num_devices;
 
428
        __le32 sectorsize;
 
429
        __le32 nodesize;
 
430
        __le32 leafsize;
 
431
        __le32 stripesize;
 
432
        __le32 sys_chunk_array_size;
 
433
        __le64 chunk_root_generation;
 
434
        __le64 compat_flags;
 
435
        __le64 compat_ro_flags;
 
436
        __le64 incompat_flags;
 
437
        __le16 csum_type;
 
438
        u8 root_level;
 
439
        u8 chunk_root_level;
 
440
        u8 log_root_level;
 
441
        struct btrfs_dev_item dev_item;
 
442
 
 
443
        char label[BTRFS_LABEL_SIZE];
 
444
 
 
445
        __le64 cache_generation;
 
446
 
 
447
        /* future expansion */
 
448
        __le64 reserved[31];
 
449
        u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
 
450
        struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
 
451
} __attribute__ ((__packed__));
 
452
 
 
453
/*
 
454
 * Compat flags that we support.  If any incompat flags are set other than the
 
455
 * ones specified below then we will fail to mount
 
456
 */
 
457
#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF    (1ULL << 0)
 
458
#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL   (1ULL << 1)
 
459
#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS     (1ULL << 2)
 
460
#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO     (1ULL << 3)
 
461
 
 
462
#define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 
463
#define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
 
464
#define BTRFS_FEATURE_INCOMPAT_SUPP                     \
 
465
        (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |         \
 
466
         BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
 
467
         BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
 
468
         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO)
 
469
 
 
470
/*
 
471
 * A leaf is full of items. offset and size tell us where to find
 
472
 * the item in the leaf (relative to the start of the data area)
 
473
 */
 
474
struct btrfs_item {
 
475
        struct btrfs_disk_key key;
 
476
        __le32 offset;
 
477
        __le32 size;
 
478
} __attribute__ ((__packed__));
 
479
 
 
480
/*
 
481
 * leaves have an item area and a data area:
 
482
 * [item0, item1....itemN] [free space] [dataN...data1, data0]
 
483
 *
 
484
 * The data is separate from the items to get the keys closer together
 
485
 * during searches.
 
486
 */
 
487
struct btrfs_leaf {
 
488
        struct btrfs_header header;
 
489
        struct btrfs_item items[];
 
490
} __attribute__ ((__packed__));
 
491
 
 
492
/*
 
493
 * all non-leaf blocks are nodes, they hold only keys and pointers to
 
494
 * other blocks
 
495
 */
 
496
struct btrfs_key_ptr {
 
497
        struct btrfs_disk_key key;
 
498
        __le64 blockptr;
 
499
        __le64 generation;
 
500
} __attribute__ ((__packed__));
 
501
 
 
502
struct btrfs_node {
 
503
        struct btrfs_header header;
 
504
        struct btrfs_key_ptr ptrs[];
 
505
} __attribute__ ((__packed__));
 
506
 
 
507
/*
 
508
 * btrfs_paths remember the path taken from the root down to the leaf.
 
509
 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 
510
 * to any other levels that are present.
 
511
 *
 
512
 * The slots array records the index of the item or block pointer
 
513
 * used while walking the tree.
 
514
 */
 
515
struct btrfs_path {
 
516
        struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
 
517
        int slots[BTRFS_MAX_LEVEL];
 
518
        /* if there is real range locking, this locks field will change */
 
519
        int locks[BTRFS_MAX_LEVEL];
 
520
        int reada;
 
521
        /* keep some upper locks as we walk down */
 
522
        int lowest_level;
 
523
 
 
524
        /*
 
525
         * set by btrfs_split_item, tells search_slot to keep all locks
 
526
         * and to force calls to keep space in the nodes
 
527
         */
 
528
        unsigned int search_for_split:1;
 
529
        unsigned int keep_locks:1;
 
530
        unsigned int skip_locking:1;
 
531
        unsigned int leave_spinning:1;
 
532
        unsigned int search_commit_root:1;
 
533
};
 
534
 
 
535
/*
 
536
 * items in the extent btree are used to record the objectid of the
 
537
 * owner of the block and the number of references
 
538
 */
 
539
 
 
540
struct btrfs_extent_item {
 
541
        __le64 refs;
 
542
        __le64 generation;
 
543
        __le64 flags;
 
544
} __attribute__ ((__packed__));
 
545
 
 
546
struct btrfs_extent_item_v0 {
 
547
        __le32 refs;
 
548
} __attribute__ ((__packed__));
 
549
 
 
550
#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
 
551
                                        sizeof(struct btrfs_item))
 
552
 
 
553
#define BTRFS_EXTENT_FLAG_DATA          (1ULL << 0)
 
554
#define BTRFS_EXTENT_FLAG_TREE_BLOCK    (1ULL << 1)
 
555
 
 
556
/* following flags only apply to tree blocks */
 
557
 
 
558
/* use full backrefs for extent pointers in the block */
 
559
#define BTRFS_BLOCK_FLAG_FULL_BACKREF   (1ULL << 8)
 
560
 
 
561
/*
 
562
 * this flag is only used internally by scrub and may be changed at any time
 
563
 * it is only declared here to avoid collisions
 
564
 */
 
565
#define BTRFS_EXTENT_FLAG_SUPER         (1ULL << 48)
 
566
 
 
567
struct btrfs_tree_block_info {
 
568
        struct btrfs_disk_key key;
 
569
        u8 level;
 
570
} __attribute__ ((__packed__));
 
571
 
 
572
struct btrfs_extent_data_ref {
 
573
        __le64 root;
 
574
        __le64 objectid;
 
575
        __le64 offset;
 
576
        __le32 count;
 
577
} __attribute__ ((__packed__));
 
578
 
 
579
struct btrfs_shared_data_ref {
 
580
        __le32 count;
 
581
} __attribute__ ((__packed__));
 
582
 
 
583
struct btrfs_extent_inline_ref {
 
584
        u8 type;
 
585
        __le64 offset;
 
586
} __attribute__ ((__packed__));
 
587
 
 
588
/* old style backrefs item */
 
589
struct btrfs_extent_ref_v0 {
 
590
        __le64 root;
 
591
        __le64 generation;
 
592
        __le64 objectid;
 
593
        __le32 count;
 
594
} __attribute__ ((__packed__));
 
595
 
 
596
 
 
597
/* dev extents record free space on individual devices.  The owner
 
598
 * field points back to the chunk allocation mapping tree that allocated
 
599
 * the extent.  The chunk tree uuid field is a way to double check the owner
 
600
 */
 
601
struct btrfs_dev_extent {
 
602
        __le64 chunk_tree;
 
603
        __le64 chunk_objectid;
 
604
        __le64 chunk_offset;
 
605
        __le64 length;
 
606
        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 
607
} __attribute__ ((__packed__));
 
608
 
 
609
struct btrfs_inode_ref {
 
610
        __le64 index;
 
611
        __le16 name_len;
 
612
        /* name goes here */
 
613
} __attribute__ ((__packed__));
 
614
 
 
615
struct btrfs_timespec {
 
616
        __le64 sec;
 
617
        __le32 nsec;
 
618
} __attribute__ ((__packed__));
 
619
 
 
620
enum btrfs_compression_type {
 
621
        BTRFS_COMPRESS_NONE  = 0,
 
622
        BTRFS_COMPRESS_ZLIB  = 1,
 
623
        BTRFS_COMPRESS_LZO   = 2,
 
624
        BTRFS_COMPRESS_TYPES = 2,
 
625
        BTRFS_COMPRESS_LAST  = 3,
 
626
};
 
627
 
 
628
struct btrfs_inode_item {
 
629
        /* nfs style generation number */
 
630
        __le64 generation;
 
631
        /* transid that last touched this inode */
 
632
        __le64 transid;
 
633
        __le64 size;
 
634
        __le64 nbytes;
 
635
        __le64 block_group;
 
636
        __le32 nlink;
 
637
        __le32 uid;
 
638
        __le32 gid;
 
639
        __le32 mode;
 
640
        __le64 rdev;
 
641
        __le64 flags;
 
642
 
 
643
        /* modification sequence number for NFS */
 
644
        __le64 sequence;
 
645
 
 
646
        /*
 
647
         * a little future expansion, for more than this we can
 
648
         * just grow the inode item and version it
 
649
         */
 
650
        __le64 reserved[4];
 
651
        struct btrfs_timespec atime;
 
652
        struct btrfs_timespec ctime;
 
653
        struct btrfs_timespec mtime;
 
654
        struct btrfs_timespec otime;
 
655
} __attribute__ ((__packed__));
 
656
 
 
657
struct btrfs_dir_log_item {
 
658
        __le64 end;
 
659
} __attribute__ ((__packed__));
 
660
 
 
661
struct btrfs_dir_item {
 
662
        struct btrfs_disk_key location;
 
663
        __le64 transid;
 
664
        __le16 data_len;
 
665
        __le16 name_len;
 
666
        u8 type;
 
667
} __attribute__ ((__packed__));
 
668
 
 
669
#define BTRFS_ROOT_SUBVOL_RDONLY        (1ULL << 0)
 
670
 
 
671
struct btrfs_root_item {
 
672
        struct btrfs_inode_item inode;
 
673
        __le64 generation;
 
674
        __le64 root_dirid;
 
675
        __le64 bytenr;
 
676
        __le64 byte_limit;
 
677
        __le64 bytes_used;
 
678
        __le64 last_snapshot;
 
679
        __le64 flags;
 
680
        __le32 refs;
 
681
        struct btrfs_disk_key drop_progress;
 
682
        u8 drop_level;
 
683
        u8 level;
 
684
} __attribute__ ((__packed__));
 
685
 
 
686
/*
 
687
 * this is used for both forward and backward root refs
 
688
 */
 
689
struct btrfs_root_ref {
 
690
        __le64 dirid;
 
691
        __le64 sequence;
 
692
        __le16 name_len;
 
693
} __attribute__ ((__packed__));
 
694
 
 
695
#define BTRFS_FILE_EXTENT_INLINE 0
 
696
#define BTRFS_FILE_EXTENT_REG 1
 
697
#define BTRFS_FILE_EXTENT_PREALLOC 2
 
698
 
 
699
struct btrfs_file_extent_item {
 
700
        /*
 
701
         * transaction id that created this extent
 
702
         */
 
703
        __le64 generation;
 
704
        /*
 
705
         * max number of bytes to hold this extent in ram
 
706
         * when we split a compressed extent we can't know how big
 
707
         * each of the resulting pieces will be.  So, this is
 
708
         * an upper limit on the size of the extent in ram instead of
 
709
         * an exact limit.
 
710
         */
 
711
        __le64 ram_bytes;
 
712
 
 
713
        /*
 
714
         * 32 bits for the various ways we might encode the data,
 
715
         * including compression and encryption.  If any of these
 
716
         * are set to something a given disk format doesn't understand
 
717
         * it is treated like an incompat flag for reading and writing,
 
718
         * but not for stat.
 
719
         */
 
720
        u8 compression;
 
721
        u8 encryption;
 
722
        __le16 other_encoding; /* spare for later use */
 
723
 
 
724
        /* are we inline data or a real extent? */
 
725
        u8 type;
 
726
 
 
727
        /*
 
728
         * disk space consumed by the extent, checksum blocks are included
 
729
         * in these numbers
 
730
         */
 
731
        __le64 disk_bytenr;
 
732
        __le64 disk_num_bytes;
 
733
        /*
 
734
         * the logical offset in file blocks (no csums)
 
735
         * this extent record is for.  This allows a file extent to point
 
736
         * into the middle of an existing extent on disk, sharing it
 
737
         * between two snapshots (useful if some bytes in the middle of the
 
738
         * extent have changed
 
739
         */
 
740
        __le64 offset;
 
741
        /*
 
742
         * the logical number of file blocks (no csums included).  This
 
743
         * always reflects the size uncompressed and without encoding.
 
744
         */
 
745
        __le64 num_bytes;
 
746
 
 
747
} __attribute__ ((__packed__));
 
748
 
 
749
struct btrfs_csum_item {
 
750
        u8 csum;
 
751
} __attribute__ ((__packed__));
 
752
 
 
753
/* different types of block groups (and chunks) */
 
754
#define BTRFS_BLOCK_GROUP_DATA     (1 << 0)
 
755
#define BTRFS_BLOCK_GROUP_SYSTEM   (1 << 1)
 
756
#define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
 
757
#define BTRFS_BLOCK_GROUP_RAID0    (1 << 3)
 
758
#define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)
 
759
#define BTRFS_BLOCK_GROUP_DUP      (1 << 5)
 
760
#define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)
 
761
#define BTRFS_NR_RAID_TYPES        5
 
762
 
 
763
struct btrfs_block_group_item {
 
764
        __le64 used;
 
765
        __le64 chunk_objectid;
 
766
        __le64 flags;
 
767
} __attribute__ ((__packed__));
 
768
 
 
769
struct btrfs_space_info {
 
770
        u64 flags;
 
771
 
 
772
        u64 total_bytes;        /* total bytes in the space,
 
773
                                   this doesn't take mirrors into account */
 
774
        u64 bytes_used;         /* total bytes used,
 
775
                                   this doesn't take mirrors into account */
 
776
        u64 bytes_pinned;       /* total bytes pinned, will be freed when the
 
777
                                   transaction finishes */
 
778
        u64 bytes_reserved;     /* total bytes the allocator has reserved for
 
779
                                   current allocations */
 
780
        u64 bytes_readonly;     /* total bytes that are read only */
 
781
 
 
782
        u64 bytes_may_use;      /* number of bytes that may be used for
 
783
                                   delalloc/allocations */
 
784
        u64 disk_used;          /* total bytes used on disk */
 
785
        u64 disk_total;         /* total bytes on disk, takes mirrors into
 
786
                                   account */
 
787
 
 
788
        /*
 
789
         * we bump reservation progress every time we decrement
 
790
         * bytes_reserved.  This way people waiting for reservations
 
791
         * know something good has happened and they can check
 
792
         * for progress.  The number here isn't to be trusted, it
 
793
         * just shows reclaim activity
 
794
         */
 
795
        unsigned long reservation_progress;
 
796
 
 
797
        unsigned int full:1;    /* indicates that we cannot allocate any more
 
798
                                   chunks for this space */
 
799
        unsigned int chunk_alloc:1;     /* set if we are allocating a chunk */
 
800
 
 
801
        unsigned int flush:1;           /* set if we are trying to make space */
 
802
 
 
803
        unsigned int force_alloc;       /* set if we need to force a chunk
 
804
                                           alloc for this space */
 
805
 
 
806
        struct list_head list;
 
807
 
 
808
        /* for block groups in our same type */
 
809
        struct list_head block_groups[BTRFS_NR_RAID_TYPES];
 
810
        spinlock_t lock;
 
811
        struct rw_semaphore groups_sem;
 
812
        wait_queue_head_t wait;
 
813
};
 
814
 
 
815
struct btrfs_block_rsv {
 
816
        u64 size;
 
817
        u64 reserved;
 
818
        struct btrfs_space_info *space_info;
 
819
        spinlock_t lock;
 
820
        unsigned int full:1;
 
821
};
 
822
 
 
823
/*
 
824
 * free clusters are used to claim free space in relatively large chunks,
 
825
 * allowing us to do less seeky writes.  They are used for all metadata
 
826
 * allocations and data allocations in ssd mode.
 
827
 */
 
828
struct btrfs_free_cluster {
 
829
        spinlock_t lock;
 
830
        spinlock_t refill_lock;
 
831
        struct rb_root root;
 
832
 
 
833
        /* largest extent in this cluster */
 
834
        u64 max_size;
 
835
 
 
836
        /* first extent starting offset */
 
837
        u64 window_start;
 
838
 
 
839
        struct btrfs_block_group_cache *block_group;
 
840
        /*
 
841
         * when a cluster is allocated from a block group, we put the
 
842
         * cluster onto a list in the block group so that it can
 
843
         * be freed before the block group is freed.
 
844
         */
 
845
        struct list_head block_group_list;
 
846
};
 
847
 
 
848
enum btrfs_caching_type {
 
849
        BTRFS_CACHE_NO          = 0,
 
850
        BTRFS_CACHE_STARTED     = 1,
 
851
        BTRFS_CACHE_FAST        = 2,
 
852
        BTRFS_CACHE_FINISHED    = 3,
 
853
};
 
854
 
 
855
enum btrfs_disk_cache_state {
 
856
        BTRFS_DC_WRITTEN        = 0,
 
857
        BTRFS_DC_ERROR          = 1,
 
858
        BTRFS_DC_CLEAR          = 2,
 
859
        BTRFS_DC_SETUP          = 3,
 
860
        BTRFS_DC_NEED_WRITE     = 4,
 
861
};
 
862
 
 
863
struct btrfs_caching_control {
 
864
        struct list_head list;
 
865
        struct mutex mutex;
 
866
        wait_queue_head_t wait;
 
867
        struct btrfs_work work;
 
868
        struct btrfs_block_group_cache *block_group;
 
869
        u64 progress;
 
870
        atomic_t count;
 
871
};
 
872
 
 
873
struct btrfs_block_group_cache {
 
874
        struct btrfs_key key;
 
875
        struct btrfs_block_group_item item;
 
876
        struct btrfs_fs_info *fs_info;
 
877
        struct inode *inode;
 
878
        spinlock_t lock;
 
879
        u64 pinned;
 
880
        u64 reserved;
 
881
        u64 bytes_super;
 
882
        u64 flags;
 
883
        u64 sectorsize;
 
884
        u64 cache_generation;
 
885
        unsigned int ro:1;
 
886
        unsigned int dirty:1;
 
887
        unsigned int iref:1;
 
888
 
 
889
        int disk_cache_state;
 
890
 
 
891
        /* cache tracking stuff */
 
892
        int cached;
 
893
        struct btrfs_caching_control *caching_ctl;
 
894
        u64 last_byte_to_unpin;
 
895
 
 
896
        struct btrfs_space_info *space_info;
 
897
 
 
898
        /* free space cache stuff */
 
899
        struct btrfs_free_space_ctl *free_space_ctl;
 
900
 
 
901
        /* block group cache stuff */
 
902
        struct rb_node cache_node;
 
903
 
 
904
        /* for block groups in the same raid type */
 
905
        struct list_head list;
 
906
 
 
907
        /* usage count */
 
908
        atomic_t count;
 
909
 
 
910
        /* List of struct btrfs_free_clusters for this block group.
 
911
         * Today it will only have one thing on it, but that may change
 
912
         */
 
913
        struct list_head cluster_list;
 
914
};
 
915
 
 
916
struct reloc_control;
 
917
struct btrfs_device;
 
918
struct btrfs_fs_devices;
 
919
struct btrfs_delayed_root;
 
920
struct btrfs_fs_info {
 
921
        u8 fsid[BTRFS_FSID_SIZE];
 
922
        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 
923
        struct btrfs_root *extent_root;
 
924
        struct btrfs_root *tree_root;
 
925
        struct btrfs_root *chunk_root;
 
926
        struct btrfs_root *dev_root;
 
927
        struct btrfs_root *fs_root;
 
928
        struct btrfs_root *csum_root;
 
929
 
 
930
        /* the log root tree is a directory of all the other log roots */
 
931
        struct btrfs_root *log_root_tree;
 
932
 
 
933
        spinlock_t fs_roots_radix_lock;
 
934
        struct radix_tree_root fs_roots_radix;
 
935
 
 
936
        /* block group cache stuff */
 
937
        spinlock_t block_group_cache_lock;
 
938
        struct rb_root block_group_cache_tree;
 
939
 
 
940
        /* keep track of unallocated space */
 
941
        spinlock_t free_chunk_lock;
 
942
        u64 free_chunk_space;
 
943
 
 
944
        struct extent_io_tree freed_extents[2];
 
945
        struct extent_io_tree *pinned_extents;
 
946
 
 
947
        /* logical->physical extent mapping */
 
948
        struct btrfs_mapping_tree mapping_tree;
 
949
 
 
950
        /*
 
951
         * block reservation for extent, checksum, root tree and
 
952
         * delayed dir index item
 
953
         */
 
954
        struct btrfs_block_rsv global_block_rsv;
 
955
        /* block reservation for delay allocation */
 
956
        struct btrfs_block_rsv delalloc_block_rsv;
 
957
        /* block reservation for metadata operations */
 
958
        struct btrfs_block_rsv trans_block_rsv;
 
959
        /* block reservation for chunk tree */
 
960
        struct btrfs_block_rsv chunk_block_rsv;
 
961
        /* block reservation for delayed operations */
 
962
        struct btrfs_block_rsv delayed_block_rsv;
 
963
 
 
964
        struct btrfs_block_rsv empty_block_rsv;
 
965
 
 
966
        u64 generation;
 
967
        u64 last_trans_committed;
 
968
 
 
969
        /*
 
970
         * this is updated to the current trans every time a full commit
 
971
         * is required instead of the faster short fsync log commits
 
972
         */
 
973
        u64 last_trans_log_full_commit;
 
974
        unsigned long mount_opt:20;
 
975
        unsigned long compress_type:4;
 
976
        u64 max_inline;
 
977
        u64 alloc_start;
 
978
        struct btrfs_transaction *running_transaction;
 
979
        wait_queue_head_t transaction_throttle;
 
980
        wait_queue_head_t transaction_wait;
 
981
        wait_queue_head_t transaction_blocked_wait;
 
982
        wait_queue_head_t async_submit_wait;
 
983
 
 
984
        struct btrfs_super_block *super_copy;
 
985
        struct btrfs_super_block *super_for_commit;
 
986
        struct block_device *__bdev;
 
987
        struct super_block *sb;
 
988
        struct inode *btree_inode;
 
989
        struct backing_dev_info bdi;
 
990
        struct mutex tree_log_mutex;
 
991
        struct mutex transaction_kthread_mutex;
 
992
        struct mutex cleaner_mutex;
 
993
        struct mutex chunk_mutex;
 
994
        struct mutex volume_mutex;
 
995
        /*
 
996
         * this protects the ordered operations list only while we are
 
997
         * processing all of the entries on it.  This way we make
 
998
         * sure the commit code doesn't find the list temporarily empty
 
999
         * because another function happens to be doing non-waiting preflush
 
1000
         * before jumping into the main commit.
 
1001
         */
 
1002
        struct mutex ordered_operations_mutex;
 
1003
        struct rw_semaphore extent_commit_sem;
 
1004
 
 
1005
        struct rw_semaphore cleanup_work_sem;
 
1006
 
 
1007
        struct rw_semaphore subvol_sem;
 
1008
        struct srcu_struct subvol_srcu;
 
1009
 
 
1010
        spinlock_t trans_lock;
 
1011
        /*
 
1012
         * the reloc mutex goes with the trans lock, it is taken
 
1013
         * during commit to protect us from the relocation code
 
1014
         */
 
1015
        struct mutex reloc_mutex;
 
1016
 
 
1017
        struct list_head trans_list;
 
1018
        struct list_head hashers;
 
1019
        struct list_head dead_roots;
 
1020
        struct list_head caching_block_groups;
 
1021
 
 
1022
        spinlock_t delayed_iput_lock;
 
1023
        struct list_head delayed_iputs;
 
1024
 
 
1025
        atomic_t nr_async_submits;
 
1026
        atomic_t async_submit_draining;
 
1027
        atomic_t nr_async_bios;
 
1028
        atomic_t async_delalloc_pages;
 
1029
        atomic_t open_ioctl_trans;
 
1030
 
 
1031
        /*
 
1032
         * this is used by the balancing code to wait for all the pending
 
1033
         * ordered extents
 
1034
         */
 
1035
        spinlock_t ordered_extent_lock;
 
1036
 
 
1037
        /*
 
1038
         * all of the data=ordered extents pending writeback
 
1039
         * these can span multiple transactions and basically include
 
1040
         * every dirty data page that isn't from nodatacow
 
1041
         */
 
1042
        struct list_head ordered_extents;
 
1043
 
 
1044
        /*
 
1045
         * all of the inodes that have delalloc bytes.  It is possible for
 
1046
         * this list to be empty even when there is still dirty data=ordered
 
1047
         * extents waiting to finish IO.
 
1048
         */
 
1049
        struct list_head delalloc_inodes;
 
1050
 
 
1051
        /*
 
1052
         * special rename and truncate targets that must be on disk before
 
1053
         * we're allowed to commit.  This is basically the ext3 style
 
1054
         * data=ordered list.
 
1055
         */
 
1056
        struct list_head ordered_operations;
 
1057
 
 
1058
        /*
 
1059
         * there is a pool of worker threads for checksumming during writes
 
1060
         * and a pool for checksumming after reads.  This is because readers
 
1061
         * can run with FS locks held, and the writers may be waiting for
 
1062
         * those locks.  We don't want ordering in the pending list to cause
 
1063
         * deadlocks, and so the two are serviced separately.
 
1064
         *
 
1065
         * A third pool does submit_bio to avoid deadlocking with the other
 
1066
         * two
 
1067
         */
 
1068
        struct btrfs_workers generic_worker;
 
1069
        struct btrfs_workers workers;
 
1070
        struct btrfs_workers delalloc_workers;
 
1071
        struct btrfs_workers endio_workers;
 
1072
        struct btrfs_workers endio_meta_workers;
 
1073
        struct btrfs_workers endio_meta_write_workers;
 
1074
        struct btrfs_workers endio_write_workers;
 
1075
        struct btrfs_workers endio_freespace_worker;
 
1076
        struct btrfs_workers submit_workers;
 
1077
        struct btrfs_workers caching_workers;
 
1078
        struct btrfs_workers readahead_workers;
 
1079
 
 
1080
        /*
 
1081
         * fixup workers take dirty pages that didn't properly go through
 
1082
         * the cow mechanism and make them safe to write.  It happens
 
1083
         * for the sys_munmap function call path
 
1084
         */
 
1085
        struct btrfs_workers fixup_workers;
 
1086
        struct btrfs_workers delayed_workers;
 
1087
        struct task_struct *transaction_kthread;
 
1088
        struct task_struct *cleaner_kthread;
 
1089
        int thread_pool_size;
 
1090
 
 
1091
        struct kobject super_kobj;
 
1092
        struct completion kobj_unregister;
 
1093
        int do_barriers;
 
1094
        int closing;
 
1095
        int log_root_recovering;
 
1096
        int enospc_unlink;
 
1097
        int trans_no_join;
 
1098
 
 
1099
        u64 total_pinned;
 
1100
 
 
1101
        /* protected by the delalloc lock, used to keep from writing
 
1102
         * metadata until there is a nice batch
 
1103
         */
 
1104
        u64 dirty_metadata_bytes;
 
1105
        struct list_head dirty_cowonly_roots;
 
1106
 
 
1107
        struct btrfs_fs_devices *fs_devices;
 
1108
 
 
1109
        /*
 
1110
         * the space_info list is almost entirely read only.  It only changes
 
1111
         * when we add a new raid type to the FS, and that happens
 
1112
         * very rarely.  RCU is used to protect it.
 
1113
         */
 
1114
        struct list_head space_info;
 
1115
 
 
1116
        struct reloc_control *reloc_ctl;
 
1117
 
 
1118
        spinlock_t delalloc_lock;
 
1119
        u64 delalloc_bytes;
 
1120
 
 
1121
        /* data_alloc_cluster is only used in ssd mode */
 
1122
        struct btrfs_free_cluster data_alloc_cluster;
 
1123
 
 
1124
        /* all metadata allocations go through this cluster */
 
1125
        struct btrfs_free_cluster meta_alloc_cluster;
 
1126
 
 
1127
        /* auto defrag inodes go here */
 
1128
        spinlock_t defrag_inodes_lock;
 
1129
        struct rb_root defrag_inodes;
 
1130
        atomic_t defrag_running;
 
1131
 
 
1132
        spinlock_t ref_cache_lock;
 
1133
        u64 total_ref_cache_size;
 
1134
 
 
1135
        u64 avail_data_alloc_bits;
 
1136
        u64 avail_metadata_alloc_bits;
 
1137
        u64 avail_system_alloc_bits;
 
1138
        u64 data_alloc_profile;
 
1139
        u64 metadata_alloc_profile;
 
1140
        u64 system_alloc_profile;
 
1141
 
 
1142
        unsigned data_chunk_allocations;
 
1143
        unsigned metadata_ratio;
 
1144
 
 
1145
        void *bdev_holder;
 
1146
 
 
1147
        /* private scrub information */
 
1148
        struct mutex scrub_lock;
 
1149
        atomic_t scrubs_running;
 
1150
        atomic_t scrub_pause_req;
 
1151
        atomic_t scrubs_paused;
 
1152
        atomic_t scrub_cancel_req;
 
1153
        wait_queue_head_t scrub_pause_wait;
 
1154
        struct rw_semaphore scrub_super_lock;
 
1155
        int scrub_workers_refcnt;
 
1156
        struct btrfs_workers scrub_workers;
 
1157
 
 
1158
        /* filesystem state */
 
1159
        u64 fs_state;
 
1160
 
 
1161
        struct btrfs_delayed_root *delayed_root;
 
1162
 
 
1163
        /* readahead tree */
 
1164
        spinlock_t reada_lock;
 
1165
        struct radix_tree_root reada_tree;
 
1166
 
 
1167
        /* next backup root to be overwritten */
 
1168
        int backup_root_index;
 
1169
};
 
1170
 
 
1171
/*
 
1172
 * in ram representation of the tree.  extent_root is used for all allocations
 
1173
 * and for the extent tree extent_root root.
 
1174
 */
 
1175
struct btrfs_root {
 
1176
        struct extent_buffer *node;
 
1177
 
 
1178
        struct extent_buffer *commit_root;
 
1179
        struct btrfs_root *log_root;
 
1180
        struct btrfs_root *reloc_root;
 
1181
 
 
1182
        struct btrfs_root_item root_item;
 
1183
        struct btrfs_key root_key;
 
1184
        struct btrfs_fs_info *fs_info;
 
1185
        struct extent_io_tree dirty_log_pages;
 
1186
 
 
1187
        struct kobject root_kobj;
 
1188
        struct completion kobj_unregister;
 
1189
        struct mutex objectid_mutex;
 
1190
 
 
1191
        spinlock_t accounting_lock;
 
1192
        struct btrfs_block_rsv *block_rsv;
 
1193
 
 
1194
        /* free ino cache stuff */
 
1195
        struct mutex fs_commit_mutex;
 
1196
        struct btrfs_free_space_ctl *free_ino_ctl;
 
1197
        enum btrfs_caching_type cached;
 
1198
        spinlock_t cache_lock;
 
1199
        wait_queue_head_t cache_wait;
 
1200
        struct btrfs_free_space_ctl *free_ino_pinned;
 
1201
        u64 cache_progress;
 
1202
        struct inode *cache_inode;
 
1203
 
 
1204
        struct mutex log_mutex;
 
1205
        wait_queue_head_t log_writer_wait;
 
1206
        wait_queue_head_t log_commit_wait[2];
 
1207
        atomic_t log_writers;
 
1208
        atomic_t log_commit[2];
 
1209
        unsigned long log_transid;
 
1210
        unsigned long last_log_commit;
 
1211
        unsigned long log_batch;
 
1212
        pid_t log_start_pid;
 
1213
        bool log_multiple_pids;
 
1214
 
 
1215
        u64 objectid;
 
1216
        u64 last_trans;
 
1217
 
 
1218
        /* data allocations are done in sectorsize units */
 
1219
        u32 sectorsize;
 
1220
 
 
1221
        /* node allocations are done in nodesize units */
 
1222
        u32 nodesize;
 
1223
 
 
1224
        /* leaf allocations are done in leafsize units */
 
1225
        u32 leafsize;
 
1226
 
 
1227
        u32 stripesize;
 
1228
 
 
1229
        u32 type;
 
1230
 
 
1231
        u64 highest_objectid;
 
1232
 
 
1233
        /* btrfs_record_root_in_trans is a multi-step process,
 
1234
         * and it can race with the balancing code.   But the
 
1235
         * race is very small, and only the first time the root
 
1236
         * is added to each transaction.  So in_trans_setup
 
1237
         * is used to tell us when more checks are required
 
1238
         */
 
1239
        unsigned long in_trans_setup;
 
1240
        int ref_cows;
 
1241
        int track_dirty;
 
1242
        int in_radix;
 
1243
 
 
1244
        u64 defrag_trans_start;
 
1245
        struct btrfs_key defrag_progress;
 
1246
        struct btrfs_key defrag_max;
 
1247
        int defrag_running;
 
1248
        char *name;
 
1249
 
 
1250
        /* the dirty list is only used by non-reference counted roots */
 
1251
        struct list_head dirty_list;
 
1252
 
 
1253
        struct list_head root_list;
 
1254
 
 
1255
        spinlock_t orphan_lock;
 
1256
        struct list_head orphan_list;
 
1257
        struct btrfs_block_rsv *orphan_block_rsv;
 
1258
        int orphan_item_inserted;
 
1259
        int orphan_cleanup_state;
 
1260
 
 
1261
        spinlock_t inode_lock;
 
1262
        /* red-black tree that keeps track of in-memory inodes */
 
1263
        struct rb_root inode_tree;
 
1264
 
 
1265
        /*
 
1266
         * radix tree that keeps track of delayed nodes of every inode,
 
1267
         * protected by inode_lock
 
1268
         */
 
1269
        struct radix_tree_root delayed_nodes_tree;
 
1270
        /*
 
1271
         * right now this just gets used so that a root has its own devid
 
1272
         * for stat.  It may be used for more later
 
1273
         */
 
1274
        dev_t anon_dev;
 
1275
 
 
1276
        int force_cow;
 
1277
};
 
1278
 
 
1279
struct btrfs_ioctl_defrag_range_args {
 
1280
        /* start of the defrag operation */
 
1281
        __u64 start;
 
1282
 
 
1283
        /* number of bytes to defrag, use (u64)-1 to say all */
 
1284
        __u64 len;
 
1285
 
 
1286
        /*
 
1287
         * flags for the operation, which can include turning
 
1288
         * on compression for this one defrag
 
1289
         */
 
1290
        __u64 flags;
 
1291
 
 
1292
        /*
 
1293
         * any extent bigger than this will be considered
 
1294
         * already defragged.  Use 0 to take the kernel default
 
1295
         * Use 1 to say every single extent must be rewritten
 
1296
         */
 
1297
        __u32 extent_thresh;
 
1298
 
 
1299
        /*
 
1300
         * which compression method to use if turning on compression
 
1301
         * for this defrag operation.  If unspecified, zlib will
 
1302
         * be used
 
1303
         */
 
1304
        __u32 compress_type;
 
1305
 
 
1306
        /* spare for later */
 
1307
        __u32 unused[4];
 
1308
};
 
1309
 
 
1310
 
 
1311
/*
 
1312
 * inode items have the data typically returned from stat and store other
 
1313
 * info about object characteristics.  There is one for every file and dir in
 
1314
 * the FS
 
1315
 */
 
1316
#define BTRFS_INODE_ITEM_KEY            1
 
1317
#define BTRFS_INODE_REF_KEY             12
 
1318
#define BTRFS_XATTR_ITEM_KEY            24
 
1319
#define BTRFS_ORPHAN_ITEM_KEY           48
 
1320
/* reserve 2-15 close to the inode for later flexibility */
 
1321
 
 
1322
/*
 
1323
 * dir items are the name -> inode pointers in a directory.  There is one
 
1324
 * for every name in a directory.
 
1325
 */
 
1326
#define BTRFS_DIR_LOG_ITEM_KEY  60
 
1327
#define BTRFS_DIR_LOG_INDEX_KEY 72
 
1328
#define BTRFS_DIR_ITEM_KEY      84
 
1329
#define BTRFS_DIR_INDEX_KEY     96
 
1330
/*
 
1331
 * extent data is for file data
 
1332
 */
 
1333
#define BTRFS_EXTENT_DATA_KEY   108
 
1334
 
 
1335
/*
 
1336
 * extent csums are stored in a separate tree and hold csums for
 
1337
 * an entire extent on disk.
 
1338
 */
 
1339
#define BTRFS_EXTENT_CSUM_KEY   128
 
1340
 
 
1341
/*
 
1342
 * root items point to tree roots.  They are typically in the root
 
1343
 * tree used by the super block to find all the other trees
 
1344
 */
 
1345
#define BTRFS_ROOT_ITEM_KEY     132
 
1346
 
 
1347
/*
 
1348
 * root backrefs tie subvols and snapshots to the directory entries that
 
1349
 * reference them
 
1350
 */
 
1351
#define BTRFS_ROOT_BACKREF_KEY  144
 
1352
 
 
1353
/*
 
1354
 * root refs make a fast index for listing all of the snapshots and
 
1355
 * subvolumes referenced by a given root.  They point directly to the
 
1356
 * directory item in the root that references the subvol
 
1357
 */
 
1358
#define BTRFS_ROOT_REF_KEY      156
 
1359
 
 
1360
/*
 
1361
 * extent items are in the extent map tree.  These record which blocks
 
1362
 * are used, and how many references there are to each block
 
1363
 */
 
1364
#define BTRFS_EXTENT_ITEM_KEY   168
 
1365
 
 
1366
#define BTRFS_TREE_BLOCK_REF_KEY        176
 
1367
 
 
1368
#define BTRFS_EXTENT_DATA_REF_KEY       178
 
1369
 
 
1370
#define BTRFS_EXTENT_REF_V0_KEY         180
 
1371
 
 
1372
#define BTRFS_SHARED_BLOCK_REF_KEY      182
 
1373
 
 
1374
#define BTRFS_SHARED_DATA_REF_KEY       184
 
1375
 
 
1376
/*
 
1377
 * block groups give us hints into the extent allocation trees.  Which
 
1378
 * blocks are free etc etc
 
1379
 */
 
1380
#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
 
1381
 
 
1382
#define BTRFS_DEV_EXTENT_KEY    204
 
1383
#define BTRFS_DEV_ITEM_KEY      216
 
1384
#define BTRFS_CHUNK_ITEM_KEY    228
 
1385
 
 
1386
/*
 
1387
 * string items are for debugging.  They just store a short string of
 
1388
 * data in the FS
 
1389
 */
 
1390
#define BTRFS_STRING_ITEM_KEY   253
 
1391
 
 
1392
/*
 
1393
 * Flags for mount options.
 
1394
 *
 
1395
 * Note: don't forget to add new options to btrfs_show_options()
 
1396
 */
 
1397
#define BTRFS_MOUNT_NODATASUM           (1 << 0)
 
1398
#define BTRFS_MOUNT_NODATACOW           (1 << 1)
 
1399
#define BTRFS_MOUNT_NOBARRIER           (1 << 2)
 
1400
#define BTRFS_MOUNT_SSD                 (1 << 3)
 
1401
#define BTRFS_MOUNT_DEGRADED            (1 << 4)
 
1402
#define BTRFS_MOUNT_COMPRESS            (1 << 5)
 
1403
#define BTRFS_MOUNT_NOTREELOG           (1 << 6)
 
1404
#define BTRFS_MOUNT_FLUSHONCOMMIT       (1 << 7)
 
1405
#define BTRFS_MOUNT_SSD_SPREAD          (1 << 8)
 
1406
#define BTRFS_MOUNT_NOSSD               (1 << 9)
 
1407
#define BTRFS_MOUNT_DISCARD             (1 << 10)
 
1408
#define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)
 
1409
#define BTRFS_MOUNT_SPACE_CACHE         (1 << 12)
 
1410
#define BTRFS_MOUNT_CLEAR_CACHE         (1 << 13)
 
1411
#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
 
1412
#define BTRFS_MOUNT_ENOSPC_DEBUG         (1 << 15)
 
1413
#define BTRFS_MOUNT_AUTO_DEFRAG         (1 << 16)
 
1414
#define BTRFS_MOUNT_INODE_MAP_CACHE     (1 << 17)
 
1415
#define BTRFS_MOUNT_RECOVERY            (1 << 18)
 
1416
 
 
1417
#define btrfs_clear_opt(o, opt)         ((o) &= ~BTRFS_MOUNT_##opt)
 
1418
#define btrfs_set_opt(o, opt)           ((o) |= BTRFS_MOUNT_##opt)
 
1419
#define btrfs_test_opt(root, opt)       ((root)->fs_info->mount_opt & \
 
1420
                                         BTRFS_MOUNT_##opt)
 
1421
/*
 
1422
 * Inode flags
 
1423
 */
 
1424
#define BTRFS_INODE_NODATASUM           (1 << 0)
 
1425
#define BTRFS_INODE_NODATACOW           (1 << 1)
 
1426
#define BTRFS_INODE_READONLY            (1 << 2)
 
1427
#define BTRFS_INODE_NOCOMPRESS          (1 << 3)
 
1428
#define BTRFS_INODE_PREALLOC            (1 << 4)
 
1429
#define BTRFS_INODE_SYNC                (1 << 5)
 
1430
#define BTRFS_INODE_IMMUTABLE           (1 << 6)
 
1431
#define BTRFS_INODE_APPEND              (1 << 7)
 
1432
#define BTRFS_INODE_NODUMP              (1 << 8)
 
1433
#define BTRFS_INODE_NOATIME             (1 << 9)
 
1434
#define BTRFS_INODE_DIRSYNC             (1 << 10)
 
1435
#define BTRFS_INODE_COMPRESS            (1 << 11)
 
1436
 
 
1437
#define BTRFS_INODE_ROOT_ITEM_INIT      (1 << 31)
 
1438
 
 
1439
/* some macros to generate set/get funcs for the struct fields.  This
 
1440
 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
 
1441
 * one for u8:
 
1442
 */
 
1443
#define le8_to_cpu(v) (v)
 
1444
#define cpu_to_le8(v) (v)
 
1445
#define __le8 u8
 
1446
 
 
1447
#define read_eb_member(eb, ptr, type, member, result) (                 \
 
1448
        read_extent_buffer(eb, (char *)(result),                        \
 
1449
                           ((unsigned long)(ptr)) +                     \
 
1450
                            offsetof(type, member),                     \
 
1451
                           sizeof(((type *)0)->member)))
 
1452
 
 
1453
#define write_eb_member(eb, ptr, type, member, result) (                \
 
1454
        write_extent_buffer(eb, (char *)(result),                       \
 
1455
                           ((unsigned long)(ptr)) +                     \
 
1456
                            offsetof(type, member),                     \
 
1457
                           sizeof(((type *)0)->member)))
 
1458
 
 
1459
#ifndef BTRFS_SETGET_FUNCS
 
1460
#define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
 
1461
u##bits btrfs_##name(struct extent_buffer *eb, type *s);                \
 
1462
void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
 
1463
#endif
 
1464
 
 
1465
#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
 
1466
static inline u##bits btrfs_##name(struct extent_buffer *eb)            \
 
1467
{                                                                       \
 
1468
        type *p = page_address(eb->first_page);                         \
 
1469
        u##bits res = le##bits##_to_cpu(p->member);                     \
 
1470
        return res;                                                     \
 
1471
}                                                                       \
 
1472
static inline void btrfs_set_##name(struct extent_buffer *eb,           \
 
1473
                                    u##bits val)                        \
 
1474
{                                                                       \
 
1475
        type *p = page_address(eb->first_page);                         \
 
1476
        p->member = cpu_to_le##bits(val);                               \
 
1477
}
 
1478
 
 
1479
#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
 
1480
static inline u##bits btrfs_##name(type *s)                             \
 
1481
{                                                                       \
 
1482
        return le##bits##_to_cpu(s->member);                            \
 
1483
}                                                                       \
 
1484
static inline void btrfs_set_##name(type *s, u##bits val)               \
 
1485
{                                                                       \
 
1486
        s->member = cpu_to_le##bits(val);                               \
 
1487
}
 
1488
 
 
1489
BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
 
1490
BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
 
1491
BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
 
1492
BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
 
1493
BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
 
1494
BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
 
1495
                   start_offset, 64);
 
1496
BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
 
1497
BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
 
1498
BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
 
1499
BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
 
1500
BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
 
1501
BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
 
1502
 
 
1503
BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
 
1504
BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
 
1505
                         total_bytes, 64);
 
1506
BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
 
1507
                         bytes_used, 64);
 
1508
BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
 
1509
                         io_align, 32);
 
1510
BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
 
1511
                         io_width, 32);
 
1512
BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
 
1513
                         sector_size, 32);
 
1514
BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
 
1515
BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
 
1516
                         dev_group, 32);
 
1517
BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
 
1518
                         seek_speed, 8);
 
1519
BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
 
1520
                         bandwidth, 8);
 
1521
BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
 
1522
                         generation, 64);
 
1523
 
 
1524
static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
 
1525
{
 
1526
        return (char *)d + offsetof(struct btrfs_dev_item, uuid);
 
1527
}
 
1528
 
 
1529
static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
 
1530
{
 
1531
        return (char *)d + offsetof(struct btrfs_dev_item, fsid);
 
1532
}
 
1533
 
 
1534
BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
 
1535
BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
 
1536
BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
 
1537
BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
 
1538
BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
 
1539
BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
 
1540
BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
 
1541
BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
 
1542
BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
 
1543
BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
 
1544
BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
 
1545
 
 
1546
static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
 
1547
{
 
1548
        return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
 
1549
}
 
1550
 
 
1551
BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
 
1552
BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
 
1553
BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
 
1554
                         stripe_len, 64);
 
1555
BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
 
1556
                         io_align, 32);
 
1557
BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
 
1558
                         io_width, 32);
 
1559
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
 
1560
                         sector_size, 32);
 
1561
BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
 
1562
BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
 
1563
                         num_stripes, 16);
 
1564
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
 
1565
                         sub_stripes, 16);
 
1566
BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
 
1567
BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
 
1568
 
 
1569
static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
 
1570
                                                   int nr)
 
1571
{
 
1572
        unsigned long offset = (unsigned long)c;
 
1573
        offset += offsetof(struct btrfs_chunk, stripe);
 
1574
        offset += nr * sizeof(struct btrfs_stripe);
 
1575
        return (struct btrfs_stripe *)offset;
 
1576
}
 
1577
 
 
1578
static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
 
1579
{
 
1580
        return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
 
1581
}
 
1582
 
 
1583
static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
 
1584
                                         struct btrfs_chunk *c, int nr)
 
1585
{
 
1586
        return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
 
1587
}
 
1588
 
 
1589
static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
 
1590
                                         struct btrfs_chunk *c, int nr)
 
1591
{
 
1592
        return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
 
1593
}
 
1594
 
 
1595
/* struct btrfs_block_group_item */
 
1596
BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
 
1597
                         used, 64);
 
1598
BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
 
1599
                         used, 64);
 
1600
BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
 
1601
                        struct btrfs_block_group_item, chunk_objectid, 64);
 
1602
 
 
1603
BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
 
1604
                   struct btrfs_block_group_item, chunk_objectid, 64);
 
1605
BTRFS_SETGET_FUNCS(disk_block_group_flags,
 
1606
                   struct btrfs_block_group_item, flags, 64);
 
1607
BTRFS_SETGET_STACK_FUNCS(block_group_flags,
 
1608
                        struct btrfs_block_group_item, flags, 64);
 
1609
 
 
1610
/* struct btrfs_inode_ref */
 
1611
BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
 
1612
BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
 
1613
 
 
1614
/* struct btrfs_inode_item */
 
1615
BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
 
1616
BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
 
1617
BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
 
1618
BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
 
1619
BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
 
1620
BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
 
1621
BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
 
1622
BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
 
1623
BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
 
1624
BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
 
1625
BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
 
1626
BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
 
1627
 
 
1628
static inline struct btrfs_timespec *
 
1629
btrfs_inode_atime(struct btrfs_inode_item *inode_item)
 
1630
{
 
1631
        unsigned long ptr = (unsigned long)inode_item;
 
1632
        ptr += offsetof(struct btrfs_inode_item, atime);
 
1633
        return (struct btrfs_timespec *)ptr;
 
1634
}
 
1635
 
 
1636
static inline struct btrfs_timespec *
 
1637
btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
 
1638
{
 
1639
        unsigned long ptr = (unsigned long)inode_item;
 
1640
        ptr += offsetof(struct btrfs_inode_item, mtime);
 
1641
        return (struct btrfs_timespec *)ptr;
 
1642
}
 
1643
 
 
1644
static inline struct btrfs_timespec *
 
1645
btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
 
1646
{
 
1647
        unsigned long ptr = (unsigned long)inode_item;
 
1648
        ptr += offsetof(struct btrfs_inode_item, ctime);
 
1649
        return (struct btrfs_timespec *)ptr;
 
1650
}
 
1651
 
 
1652
BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
 
1653
BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
 
1654
 
 
1655
/* struct btrfs_dev_extent */
 
1656
BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
 
1657
                   chunk_tree, 64);
 
1658
BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
 
1659
                   chunk_objectid, 64);
 
1660
BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
 
1661
                   chunk_offset, 64);
 
1662
BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
 
1663
 
 
1664
static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
 
1665
{
 
1666
        unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
 
1667
        return (u8 *)((unsigned long)dev + ptr);
 
1668
}
 
1669
 
 
1670
BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
 
1671
BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
 
1672
                   generation, 64);
 
1673
BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
 
1674
 
 
1675
BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
 
1676
 
 
1677
 
 
1678
BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
 
1679
 
 
1680
static inline void btrfs_tree_block_key(struct extent_buffer *eb,
 
1681
                                        struct btrfs_tree_block_info *item,
 
1682
                                        struct btrfs_disk_key *key)
 
1683
{
 
1684
        read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
 
1685
}
 
1686
 
 
1687
static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
 
1688
                                            struct btrfs_tree_block_info *item,
 
1689
                                            struct btrfs_disk_key *key)
 
1690
{
 
1691
        write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
 
1692
}
 
1693
 
 
1694
BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
 
1695
                   root, 64);
 
1696
BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
 
1697
                   objectid, 64);
 
1698
BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
 
1699
                   offset, 64);
 
1700
BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
 
1701
                   count, 32);
 
1702
 
 
1703
BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
 
1704
                   count, 32);
 
1705
 
 
1706
BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
 
1707
                   type, 8);
 
1708
BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
 
1709
                   offset, 64);
 
1710
 
 
1711
static inline u32 btrfs_extent_inline_ref_size(int type)
 
1712
{
 
1713
        if (type == BTRFS_TREE_BLOCK_REF_KEY ||
 
1714
            type == BTRFS_SHARED_BLOCK_REF_KEY)
 
1715
                return sizeof(struct btrfs_extent_inline_ref);
 
1716
        if (type == BTRFS_SHARED_DATA_REF_KEY)
 
1717
                return sizeof(struct btrfs_shared_data_ref) +
 
1718
                       sizeof(struct btrfs_extent_inline_ref);
 
1719
        if (type == BTRFS_EXTENT_DATA_REF_KEY)
 
1720
                return sizeof(struct btrfs_extent_data_ref) +
 
1721
                       offsetof(struct btrfs_extent_inline_ref, offset);
 
1722
        BUG();
 
1723
        return 0;
 
1724
}
 
1725
 
 
1726
BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
 
1727
BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
 
1728
                   generation, 64);
 
1729
BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
 
1730
BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
 
1731
 
 
1732
/* struct btrfs_node */
 
1733
BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 
1734
BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
 
1735
 
 
1736
static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
 
1737
{
 
1738
        unsigned long ptr;
 
1739
        ptr = offsetof(struct btrfs_node, ptrs) +
 
1740
                sizeof(struct btrfs_key_ptr) * nr;
 
1741
        return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
 
1742
}
 
1743
 
 
1744
static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
 
1745
                                           int nr, u64 val)
 
1746
{
 
1747
        unsigned long ptr;
 
1748
        ptr = offsetof(struct btrfs_node, ptrs) +
 
1749
                sizeof(struct btrfs_key_ptr) * nr;
 
1750
        btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
 
1751
}
 
1752
 
 
1753
static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
 
1754
{
 
1755
        unsigned long ptr;
 
1756
        ptr = offsetof(struct btrfs_node, ptrs) +
 
1757
                sizeof(struct btrfs_key_ptr) * nr;
 
1758
        return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
 
1759
}
 
1760
 
 
1761
static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
 
1762
                                                 int nr, u64 val)
 
1763
{
 
1764
        unsigned long ptr;
 
1765
        ptr = offsetof(struct btrfs_node, ptrs) +
 
1766
                sizeof(struct btrfs_key_ptr) * nr;
 
1767
        btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
 
1768
}
 
1769
 
 
1770
static inline unsigned long btrfs_node_key_ptr_offset(int nr)
 
1771
{
 
1772
        return offsetof(struct btrfs_node, ptrs) +
 
1773
                sizeof(struct btrfs_key_ptr) * nr;
 
1774
}
 
1775
 
 
1776
void btrfs_node_key(struct extent_buffer *eb,
 
1777
                    struct btrfs_disk_key *disk_key, int nr);
 
1778
 
 
1779
static inline void btrfs_set_node_key(struct extent_buffer *eb,
 
1780
                                      struct btrfs_disk_key *disk_key, int nr)
 
1781
{
 
1782
        unsigned long ptr;
 
1783
        ptr = btrfs_node_key_ptr_offset(nr);
 
1784
        write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
 
1785
                       struct btrfs_key_ptr, key, disk_key);
 
1786
}
 
1787
 
 
1788
/* struct btrfs_item */
 
1789
BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
 
1790
BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
 
1791
 
 
1792
static inline unsigned long btrfs_item_nr_offset(int nr)
 
1793
{
 
1794
        return offsetof(struct btrfs_leaf, items) +
 
1795
                sizeof(struct btrfs_item) * nr;
 
1796
}
 
1797
 
 
1798
static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
 
1799
                                               int nr)
 
1800
{
 
1801
        return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 
1802
}
 
1803
 
 
1804
static inline u32 btrfs_item_end(struct extent_buffer *eb,
 
1805
                                 struct btrfs_item *item)
 
1806
{
 
1807
        return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
 
1808
}
 
1809
 
 
1810
static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
 
1811
{
 
1812
        return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
 
1813
}
 
1814
 
 
1815
static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
 
1816
{
 
1817
        return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
 
1818
}
 
1819
 
 
1820
static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
 
1821
{
 
1822
        return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
 
1823
}
 
1824
 
 
1825
static inline void btrfs_item_key(struct extent_buffer *eb,
 
1826
                           struct btrfs_disk_key *disk_key, int nr)
 
1827
{
 
1828
        struct btrfs_item *item = btrfs_item_nr(eb, nr);
 
1829
        read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 
1830
}
 
1831
 
 
1832
static inline void btrfs_set_item_key(struct extent_buffer *eb,
 
1833
                               struct btrfs_disk_key *disk_key, int nr)
 
1834
{
 
1835
        struct btrfs_item *item = btrfs_item_nr(eb, nr);
 
1836
        write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 
1837
}
 
1838
 
 
1839
BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
 
1840
 
 
1841
/*
 
1842
 * struct btrfs_root_ref
 
1843
 */
 
1844
BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
 
1845
BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
 
1846
BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
 
1847
 
 
1848
/* struct btrfs_dir_item */
 
1849
BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
 
1850
BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
 
1851
BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
 
1852
BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
 
1853
 
 
1854
static inline void btrfs_dir_item_key(struct extent_buffer *eb,
 
1855
                                      struct btrfs_dir_item *item,
 
1856
                                      struct btrfs_disk_key *key)
 
1857
{
 
1858
        read_eb_member(eb, item, struct btrfs_dir_item, location, key);
 
1859
}
 
1860
 
 
1861
static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
 
1862
                                          struct btrfs_dir_item *item,
 
1863
                                          struct btrfs_disk_key *key)
 
1864
{
 
1865
        write_eb_member(eb, item, struct btrfs_dir_item, location, key);
 
1866
}
 
1867
 
 
1868
BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
 
1869
                   num_entries, 64);
 
1870
BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
 
1871
                   num_bitmaps, 64);
 
1872
BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
 
1873
                   generation, 64);
 
1874
 
 
1875
static inline void btrfs_free_space_key(struct extent_buffer *eb,
 
1876
                                        struct btrfs_free_space_header *h,
 
1877
                                        struct btrfs_disk_key *key)
 
1878
{
 
1879
        read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
 
1880
}
 
1881
 
 
1882
static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
 
1883
                                            struct btrfs_free_space_header *h,
 
1884
                                            struct btrfs_disk_key *key)
 
1885
{
 
1886
        write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
 
1887
}
 
1888
 
 
1889
/* struct btrfs_disk_key */
 
1890
BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
 
1891
                         objectid, 64);
 
1892
BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
 
1893
BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
 
1894
 
 
1895
static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 
1896
                                         struct btrfs_disk_key *disk)
 
1897
{
 
1898
        cpu->offset = le64_to_cpu(disk->offset);
 
1899
        cpu->type = disk->type;
 
1900
        cpu->objectid = le64_to_cpu(disk->objectid);
 
1901
}
 
1902
 
 
1903
static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
 
1904
                                         struct btrfs_key *cpu)
 
1905
{
 
1906
        disk->offset = cpu_to_le64(cpu->offset);
 
1907
        disk->type = cpu->type;
 
1908
        disk->objectid = cpu_to_le64(cpu->objectid);
 
1909
}
 
1910
 
 
1911
static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
 
1912
                                  struct btrfs_key *key, int nr)
 
1913
{
 
1914
        struct btrfs_disk_key disk_key;
 
1915
        btrfs_node_key(eb, &disk_key, nr);
 
1916
        btrfs_disk_key_to_cpu(key, &disk_key);
 
1917
}
 
1918
 
 
1919
static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
 
1920
                                  struct btrfs_key *key, int nr)
 
1921
{
 
1922
        struct btrfs_disk_key disk_key;
 
1923
        btrfs_item_key(eb, &disk_key, nr);
 
1924
        btrfs_disk_key_to_cpu(key, &disk_key);
 
1925
}
 
1926
 
 
1927
static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
 
1928
                                      struct btrfs_dir_item *item,
 
1929
                                      struct btrfs_key *key)
 
1930
{
 
1931
        struct btrfs_disk_key disk_key;
 
1932
        btrfs_dir_item_key(eb, item, &disk_key);
 
1933
        btrfs_disk_key_to_cpu(key, &disk_key);
 
1934
}
 
1935
 
 
1936
 
 
1937
static inline u8 btrfs_key_type(struct btrfs_key *key)
 
1938
{
 
1939
        return key->type;
 
1940
}
 
1941
 
 
1942
static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
 
1943
{
 
1944
        key->type = val;
 
1945
}
 
1946
 
 
1947
/* struct btrfs_header */
 
1948
BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
 
1949
BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
 
1950
                          generation, 64);
 
1951
BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
 
1952
BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
 
1953
BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
 
1954
BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
 
1955
 
 
1956
static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
 
1957
{
 
1958
        return (btrfs_header_flags(eb) & flag) == flag;
 
1959
}
 
1960
 
 
1961
static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
 
1962
{
 
1963
        u64 flags = btrfs_header_flags(eb);
 
1964
        btrfs_set_header_flags(eb, flags | flag);
 
1965
        return (flags & flag) == flag;
 
1966
}
 
1967
 
 
1968
static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
 
1969
{
 
1970
        u64 flags = btrfs_header_flags(eb);
 
1971
        btrfs_set_header_flags(eb, flags & ~flag);
 
1972
        return (flags & flag) == flag;
 
1973
}
 
1974
 
 
1975
static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
 
1976
{
 
1977
        u64 flags = btrfs_header_flags(eb);
 
1978
        return flags >> BTRFS_BACKREF_REV_SHIFT;
 
1979
}
 
1980
 
 
1981
static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
 
1982
                                                int rev)
 
1983
{
 
1984
        u64 flags = btrfs_header_flags(eb);
 
1985
        flags &= ~BTRFS_BACKREF_REV_MASK;
 
1986
        flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
 
1987
        btrfs_set_header_flags(eb, flags);
 
1988
}
 
1989
 
 
1990
static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
 
1991
{
 
1992
        unsigned long ptr = offsetof(struct btrfs_header, fsid);
 
1993
        return (u8 *)ptr;
 
1994
}
 
1995
 
 
1996
static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
 
1997
{
 
1998
        unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);
 
1999
        return (u8 *)ptr;
 
2000
}
 
2001
 
 
2002
static inline int btrfs_is_leaf(struct extent_buffer *eb)
 
2003
{
 
2004
        return btrfs_header_level(eb) == 0;
 
2005
}
 
2006
 
 
2007
/* struct btrfs_root_item */
 
2008
BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
 
2009
                   generation, 64);
 
2010
BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
 
2011
BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
 
2012
BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
 
2013
 
 
2014
BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
 
2015
                         generation, 64);
 
2016
BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
 
2017
BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
 
2018
BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
 
2019
BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
 
2020
BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
 
2021
BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
 
2022
BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
 
2023
BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
 
2024
                         last_snapshot, 64);
 
2025
 
 
2026
static inline bool btrfs_root_readonly(struct btrfs_root *root)
 
2027
{
 
2028
        return root->root_item.flags & BTRFS_ROOT_SUBVOL_RDONLY;
 
2029
}
 
2030
 
 
2031
/* struct btrfs_root_backup */
 
2032
BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
 
2033
                   tree_root, 64);
 
2034
BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
 
2035
                   tree_root_gen, 64);
 
2036
BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
 
2037
                   tree_root_level, 8);
 
2038
 
 
2039
BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
 
2040
                   chunk_root, 64);
 
2041
BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
 
2042
                   chunk_root_gen, 64);
 
2043
BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
 
2044
                   chunk_root_level, 8);
 
2045
 
 
2046
BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
 
2047
                   extent_root, 64);
 
2048
BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
 
2049
                   extent_root_gen, 64);
 
2050
BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
 
2051
                   extent_root_level, 8);
 
2052
 
 
2053
BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
 
2054
                   fs_root, 64);
 
2055
BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
 
2056
                   fs_root_gen, 64);
 
2057
BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
 
2058
                   fs_root_level, 8);
 
2059
 
 
2060
BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
 
2061
                   dev_root, 64);
 
2062
BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
 
2063
                   dev_root_gen, 64);
 
2064
BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
 
2065
                   dev_root_level, 8);
 
2066
 
 
2067
BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
 
2068
                   csum_root, 64);
 
2069
BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
 
2070
                   csum_root_gen, 64);
 
2071
BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
 
2072
                   csum_root_level, 8);
 
2073
BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
 
2074
                   total_bytes, 64);
 
2075
BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
 
2076
                   bytes_used, 64);
 
2077
BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
 
2078
                   num_devices, 64);
 
2079
 
 
2080
/* struct btrfs_super_block */
 
2081
 
 
2082
BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
 
2083
BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
 
2084
BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
 
2085
                         generation, 64);
 
2086
BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
 
2087
BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
 
2088
                         struct btrfs_super_block, sys_chunk_array_size, 32);
 
2089
BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
 
2090
                         struct btrfs_super_block, chunk_root_generation, 64);
 
2091
BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
 
2092
                         root_level, 8);
 
2093
BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
 
2094
                         chunk_root, 64);
 
2095
BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
 
2096
                         chunk_root_level, 8);
 
2097
BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
 
2098
                         log_root, 64);
 
2099
BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
 
2100
                         log_root_transid, 64);
 
2101
BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
 
2102
                         log_root_level, 8);
 
2103
BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
 
2104
                         total_bytes, 64);
 
2105
BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
 
2106
                         bytes_used, 64);
 
2107
BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
 
2108
                         sectorsize, 32);
 
2109
BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
 
2110
                         nodesize, 32);
 
2111
BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
 
2112
                         leafsize, 32);
 
2113
BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
 
2114
                         stripesize, 32);
 
2115
BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
 
2116
                         root_dir_objectid, 64);
 
2117
BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
 
2118
                         num_devices, 64);
 
2119
BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
 
2120
                         compat_flags, 64);
 
2121
BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
 
2122
                         compat_ro_flags, 64);
 
2123
BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
 
2124
                         incompat_flags, 64);
 
2125
BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
 
2126
                         csum_type, 16);
 
2127
BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
 
2128
                         cache_generation, 64);
 
2129
 
 
2130
static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
 
2131
{
 
2132
        int t = btrfs_super_csum_type(s);
 
2133
        BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes));
 
2134
        return btrfs_csum_sizes[t];
 
2135
}
 
2136
 
 
2137
static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
 
2138
{
 
2139
        return offsetof(struct btrfs_leaf, items);
 
2140
}
 
2141
 
 
2142
/* struct btrfs_file_extent_item */
 
2143
BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
 
2144
 
 
2145
static inline unsigned long
 
2146
btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
 
2147
{
 
2148
        unsigned long offset = (unsigned long)e;
 
2149
        offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
 
2150
        return offset;
 
2151
}
 
2152
 
 
2153
static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
 
2154
{
 
2155
        return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
 
2156
}
 
2157
 
 
2158
BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
 
2159
                   disk_bytenr, 64);
 
2160
BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
 
2161
                   generation, 64);
 
2162
BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
 
2163
                   disk_num_bytes, 64);
 
2164
BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
 
2165
                  offset, 64);
 
2166
BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
 
2167
                   num_bytes, 64);
 
2168
BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
 
2169
                   ram_bytes, 64);
 
2170
BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
 
2171
                   compression, 8);
 
2172
BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
 
2173
                   encryption, 8);
 
2174
BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
 
2175
                   other_encoding, 16);
 
2176
 
 
2177
/* this returns the number of file bytes represented by the inline item.
 
2178
 * If an item is compressed, this is the uncompressed size
 
2179
 */
 
2180
static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
 
2181
                                               struct btrfs_file_extent_item *e)
 
2182
{
 
2183
        return btrfs_file_extent_ram_bytes(eb, e);
 
2184
}
 
2185
 
 
2186
/*
 
2187
 * this returns the number of bytes used by the item on disk, minus the
 
2188
 * size of any extent headers.  If a file is compressed on disk, this is
 
2189
 * the compressed size
 
2190
 */
 
2191
static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
 
2192
                                                    struct btrfs_item *e)
 
2193
{
 
2194
        unsigned long offset;
 
2195
        offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
 
2196
        return btrfs_item_size(eb, e) - offset;
 
2197
}
 
2198
 
 
2199
static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
 
2200
{
 
2201
        return sb->s_fs_info;
 
2202
}
 
2203
 
 
2204
static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
 
2205
{
 
2206
        if (level == 0)
 
2207
                return root->leafsize;
 
2208
        return root->nodesize;
 
2209
}
 
2210
 
 
2211
/* helper function to cast into the data area of the leaf. */
 
2212
#define btrfs_item_ptr(leaf, slot, type) \
 
2213
        ((type *)(btrfs_leaf_data(leaf) + \
 
2214
        btrfs_item_offset_nr(leaf, slot)))
 
2215
 
 
2216
#define btrfs_item_ptr_offset(leaf, slot) \
 
2217
        ((unsigned long)(btrfs_leaf_data(leaf) + \
 
2218
        btrfs_item_offset_nr(leaf, slot)))
 
2219
 
 
2220
static inline struct dentry *fdentry(struct file *file)
 
2221
{
 
2222
        return file->f_path.dentry;
 
2223
}
 
2224
 
 
2225
static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
 
2226
{
 
2227
        return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
 
2228
                (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
 
2229
}
 
2230
 
 
2231
static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
 
2232
{
 
2233
        return mapping_gfp_mask(mapping) & ~__GFP_FS;
 
2234
}
 
2235
 
 
2236
/* extent-tree.c */
 
2237
static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
 
2238
                                                 unsigned num_items)
 
2239
{
 
2240
        return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
 
2241
                3 * num_items;
 
2242
}
 
2243
 
 
2244
/*
 
2245
 * Doing a truncate won't result in new nodes or leaves, just what we need for
 
2246
 * COW.
 
2247
 */
 
2248
static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
 
2249
                                                 unsigned num_items)
 
2250
{
 
2251
        return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
 
2252
                num_items;
 
2253
}
 
2254
 
 
2255
void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
 
2256
int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
 
2257
                           struct btrfs_root *root, unsigned long count);
 
2258
int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
 
2259
int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
 
2260
                             struct btrfs_root *root, u64 bytenr,
 
2261
                             u64 num_bytes, u64 *refs, u64 *flags);
 
2262
int btrfs_pin_extent(struct btrfs_root *root,
 
2263
                     u64 bytenr, u64 num, int reserved);
 
2264
int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
 
2265
                                    struct btrfs_root *root,
 
2266
                                    u64 bytenr, u64 num_bytes);
 
2267
int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
 
2268
                          struct btrfs_root *root,
 
2269
                          u64 objectid, u64 offset, u64 bytenr);
 
2270
struct btrfs_block_group_cache *btrfs_lookup_block_group(
 
2271
                                                 struct btrfs_fs_info *info,
 
2272
                                                 u64 bytenr);
 
2273
void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
 
2274
u64 btrfs_find_block_group(struct btrfs_root *root,
 
2275
                           u64 search_start, u64 search_hint, int owner);
 
2276
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
 
2277
                                        struct btrfs_root *root, u32 blocksize,
 
2278
                                        u64 parent, u64 root_objectid,
 
2279
                                        struct btrfs_disk_key *key, int level,
 
2280
                                        u64 hint, u64 empty_size);
 
2281
void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
 
2282
                           struct btrfs_root *root,
 
2283
                           struct extent_buffer *buf,
 
2284
                           u64 parent, int last_ref);
 
2285
struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
 
2286
                                            struct btrfs_root *root,
 
2287
                                            u64 bytenr, u32 blocksize,
 
2288
                                            int level);
 
2289
int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
 
2290
                                     struct btrfs_root *root,
 
2291
                                     u64 root_objectid, u64 owner,
 
2292
                                     u64 offset, struct btrfs_key *ins);
 
2293
int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
 
2294
                                   struct btrfs_root *root,
 
2295
                                   u64 root_objectid, u64 owner, u64 offset,
 
2296
                                   struct btrfs_key *ins);
 
2297
int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
 
2298
                                  struct btrfs_root *root,
 
2299
                                  u64 num_bytes, u64 min_alloc_size,
 
2300
                                  u64 empty_size, u64 hint_byte,
 
2301
                                  u64 search_end, struct btrfs_key *ins,
 
2302
                                  u64 data);
 
2303
int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
2304
                  struct extent_buffer *buf, int full_backref);
 
2305
int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
2306
                  struct extent_buffer *buf, int full_backref);
 
2307
int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
 
2308
                                struct btrfs_root *root,
 
2309
                                u64 bytenr, u64 num_bytes, u64 flags,
 
2310
                                int is_data);
 
2311
int btrfs_free_extent(struct btrfs_trans_handle *trans,
 
2312
                      struct btrfs_root *root,
 
2313
                      u64 bytenr, u64 num_bytes, u64 parent,
 
2314
                      u64 root_objectid, u64 owner, u64 offset);
 
2315
 
 
2316
int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
 
2317
int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
 
2318
                                       u64 start, u64 len);
 
2319
int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
 
2320
                                struct btrfs_root *root);
 
2321
int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
 
2322
                               struct btrfs_root *root);
 
2323
int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
 
2324
                         struct btrfs_root *root,
 
2325
                         u64 bytenr, u64 num_bytes, u64 parent,
 
2326
                         u64 root_objectid, u64 owner, u64 offset);
 
2327
 
 
2328
int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
 
2329
                                    struct btrfs_root *root);
 
2330
int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
 
2331
int btrfs_free_block_groups(struct btrfs_fs_info *info);
 
2332
int btrfs_read_block_groups(struct btrfs_root *root);
 
2333
int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
 
2334
int btrfs_make_block_group(struct btrfs_trans_handle *trans,
 
2335
                           struct btrfs_root *root, u64 bytes_used,
 
2336
                           u64 type, u64 chunk_objectid, u64 chunk_offset,
 
2337
                           u64 size);
 
2338
int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 
2339
                             struct btrfs_root *root, u64 group_start);
 
2340
u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
 
2341
u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
 
2342
void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde);
 
2343
void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
 
2344
int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
 
2345
void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
 
2346
void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
 
2347
                                struct btrfs_root *root);
 
2348
int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
 
2349
                                  struct inode *inode);
 
2350
void btrfs_orphan_release_metadata(struct inode *inode);
 
2351
int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
 
2352
                                struct btrfs_pending_snapshot *pending);
 
2353
int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
 
2354
void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
 
2355
int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
 
2356
void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
 
2357
void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv);
 
2358
struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root);
 
2359
void btrfs_free_block_rsv(struct btrfs_root *root,
 
2360
                          struct btrfs_block_rsv *rsv);
 
2361
int btrfs_block_rsv_add(struct btrfs_root *root,
 
2362
                        struct btrfs_block_rsv *block_rsv,
 
2363
                        u64 num_bytes);
 
2364
int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
 
2365
                                struct btrfs_block_rsv *block_rsv,
 
2366
                                u64 num_bytes);
 
2367
int btrfs_block_rsv_check(struct btrfs_root *root,
 
2368
                          struct btrfs_block_rsv *block_rsv, int min_factor);
 
2369
int btrfs_block_rsv_refill(struct btrfs_root *root,
 
2370
                          struct btrfs_block_rsv *block_rsv,
 
2371
                          u64 min_reserved);
 
2372
int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
 
2373
                                   struct btrfs_block_rsv *block_rsv,
 
2374
                                   u64 min_reserved);
 
2375
int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
 
2376
                            struct btrfs_block_rsv *dst_rsv,
 
2377
                            u64 num_bytes);
 
2378
void btrfs_block_rsv_release(struct btrfs_root *root,
 
2379
                             struct btrfs_block_rsv *block_rsv,
 
2380
                             u64 num_bytes);
 
2381
int btrfs_set_block_group_ro(struct btrfs_root *root,
 
2382
                             struct btrfs_block_group_cache *cache);
 
2383
int btrfs_set_block_group_rw(struct btrfs_root *root,
 
2384
                             struct btrfs_block_group_cache *cache);
 
2385
void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
 
2386
u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
 
2387
int btrfs_error_unpin_extent_range(struct btrfs_root *root,
 
2388
                                   u64 start, u64 end);
 
2389
int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
 
2390
                               u64 num_bytes, u64 *actual_bytes);
 
2391
int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
 
2392
                            struct btrfs_root *root, u64 type);
 
2393
int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
 
2394
 
 
2395
int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
 
2396
/* ctree.c */
 
2397
int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
 
2398
                     int level, int *slot);
 
2399
int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
 
2400
int btrfs_previous_item(struct btrfs_root *root,
 
2401
                        struct btrfs_path *path, u64 min_objectid,
 
2402
                        int type);
 
2403
int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
 
2404
                            struct btrfs_root *root, struct btrfs_path *path,
 
2405
                            struct btrfs_key *new_key);
 
2406
struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
 
2407
struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
 
2408
int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
 
2409
                        struct btrfs_key *key, int lowest_level,
 
2410
                        int cache_only, u64 min_trans);
 
2411
int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
 
2412
                         struct btrfs_key *max_key,
 
2413
                         struct btrfs_path *path, int cache_only,
 
2414
                         u64 min_trans);
 
2415
int btrfs_cow_block(struct btrfs_trans_handle *trans,
 
2416
                    struct btrfs_root *root, struct extent_buffer *buf,
 
2417
                    struct extent_buffer *parent, int parent_slot,
 
2418
                    struct extent_buffer **cow_ret);
 
2419
int btrfs_copy_root(struct btrfs_trans_handle *trans,
 
2420
                      struct btrfs_root *root,
 
2421
                      struct extent_buffer *buf,
 
2422
                      struct extent_buffer **cow_ret, u64 new_root_objectid);
 
2423
int btrfs_block_can_be_shared(struct btrfs_root *root,
 
2424
                              struct extent_buffer *buf);
 
2425
int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
 
2426
                      *root, struct btrfs_path *path, u32 data_size);
 
2427
int btrfs_truncate_item(struct btrfs_trans_handle *trans,
 
2428
                        struct btrfs_root *root,
 
2429
                        struct btrfs_path *path,
 
2430
                        u32 new_size, int from_end);
 
2431
int btrfs_split_item(struct btrfs_trans_handle *trans,
 
2432
                     struct btrfs_root *root,
 
2433
                     struct btrfs_path *path,
 
2434
                     struct btrfs_key *new_key,
 
2435
                     unsigned long split_offset);
 
2436
int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
 
2437
                         struct btrfs_root *root,
 
2438
                         struct btrfs_path *path,
 
2439
                         struct btrfs_key *new_key);
 
2440
int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
 
2441
                      *root, struct btrfs_key *key, struct btrfs_path *p, int
 
2442
                      ins_len, int cow);
 
2443
int btrfs_realloc_node(struct btrfs_trans_handle *trans,
 
2444
                       struct btrfs_root *root, struct extent_buffer *parent,
 
2445
                       int start_slot, int cache_only, u64 *last_ret,
 
2446
                       struct btrfs_key *progress);
 
2447
void btrfs_release_path(struct btrfs_path *p);
 
2448
struct btrfs_path *btrfs_alloc_path(void);
 
2449
void btrfs_free_path(struct btrfs_path *p);
 
2450
void btrfs_set_path_blocking(struct btrfs_path *p);
 
2451
void btrfs_clear_path_blocking(struct btrfs_path *p,
 
2452
                               struct extent_buffer *held, int held_rw);
 
2453
void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
 
2454
 
 
2455
int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
2456
                   struct btrfs_path *path, int slot, int nr);
 
2457
static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
 
2458
                                 struct btrfs_root *root,
 
2459
                                 struct btrfs_path *path)
 
2460
{
 
2461
        return btrfs_del_items(trans, root, path, path->slots[0], 1);
 
2462
}
 
2463
 
 
2464
int setup_items_for_insert(struct btrfs_trans_handle *trans,
 
2465
                           struct btrfs_root *root, struct btrfs_path *path,
 
2466
                           struct btrfs_key *cpu_key, u32 *data_size,
 
2467
                           u32 total_data, u32 total_size, int nr);
 
2468
int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
 
2469
                      *root, struct btrfs_key *key, void *data, u32 data_size);
 
2470
int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
 
2471
                             struct btrfs_root *root,
 
2472
                             struct btrfs_path *path,
 
2473
                             struct btrfs_key *cpu_key, u32 *data_size, int nr);
 
2474
 
 
2475
static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
 
2476
                                          struct btrfs_root *root,
 
2477
                                          struct btrfs_path *path,
 
2478
                                          struct btrfs_key *key,
 
2479
                                          u32 data_size)
 
2480
{
 
2481
        return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
 
2482
}
 
2483
 
 
2484
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
 
2485
int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
 
2486
int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
 
2487
void btrfs_drop_snapshot(struct btrfs_root *root,
 
2488
                         struct btrfs_block_rsv *block_rsv, int update_ref);
 
2489
int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
 
2490
                        struct btrfs_root *root,
 
2491
                        struct extent_buffer *node,
 
2492
                        struct extent_buffer *parent);
 
2493
static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
 
2494
{
 
2495
        /*
 
2496
         * Get synced with close_ctree()
 
2497
         */
 
2498
        smp_mb();
 
2499
        return fs_info->closing;
 
2500
}
 
2501
static inline void free_fs_info(struct btrfs_fs_info *fs_info)
 
2502
{
 
2503
        kfree(fs_info->delayed_root);
 
2504
        kfree(fs_info->extent_root);
 
2505
        kfree(fs_info->tree_root);
 
2506
        kfree(fs_info->chunk_root);
 
2507
        kfree(fs_info->dev_root);
 
2508
        kfree(fs_info->csum_root);
 
2509
        kfree(fs_info->super_copy);
 
2510
        kfree(fs_info->super_for_commit);
 
2511
        kfree(fs_info);
 
2512
}
 
2513
 
 
2514
/* root-item.c */
 
2515
int btrfs_find_root_ref(struct btrfs_root *tree_root,
 
2516
                        struct btrfs_path *path,
 
2517
                        u64 root_id, u64 ref_id);
 
2518
int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
 
2519
                       struct btrfs_root *tree_root,
 
2520
                       u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
 
2521
                       const char *name, int name_len);
 
2522
int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
 
2523
                       struct btrfs_root *tree_root,
 
2524
                       u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
 
2525
                       const char *name, int name_len);
 
2526
int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
2527
                   struct btrfs_key *key);
 
2528
int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
 
2529
                      *root, struct btrfs_key *key, struct btrfs_root_item
 
2530
                      *item);
 
2531
int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
 
2532
                      *root, struct btrfs_key *key, struct btrfs_root_item
 
2533
                      *item);
 
2534
int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
 
2535
                         btrfs_root_item *item, struct btrfs_key *key);
 
2536
int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
 
2537
int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
 
2538
void btrfs_set_root_node(struct btrfs_root_item *item,
 
2539
                         struct extent_buffer *node);
 
2540
void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
 
2541
 
 
2542
/* dir-item.c */
 
2543
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
 
2544
                          struct btrfs_root *root, const char *name,
 
2545
                          int name_len, struct inode *dir,
 
2546
                          struct btrfs_key *location, u8 type, u64 index);
 
2547
struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
 
2548
                                             struct btrfs_root *root,
 
2549
                                             struct btrfs_path *path, u64 dir,
 
2550
                                             const char *name, int name_len,
 
2551
                                             int mod);
 
2552
struct btrfs_dir_item *
 
2553
btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
 
2554
                            struct btrfs_root *root,
 
2555
                            struct btrfs_path *path, u64 dir,
 
2556
                            u64 objectid, const char *name, int name_len,
 
2557
                            int mod);
 
2558
struct btrfs_dir_item *
 
2559
btrfs_search_dir_index_item(struct btrfs_root *root,
 
2560
                            struct btrfs_path *path, u64 dirid,
 
2561
                            const char *name, int name_len);
 
2562
struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
 
2563
                              struct btrfs_path *path,
 
2564
                              const char *name, int name_len);
 
2565
int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
 
2566
                              struct btrfs_root *root,
 
2567
                              struct btrfs_path *path,
 
2568
                              struct btrfs_dir_item *di);
 
2569
int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
 
2570
                            struct btrfs_root *root,
 
2571
                            struct btrfs_path *path, u64 objectid,
 
2572
                            const char *name, u16 name_len,
 
2573
                            const void *data, u16 data_len);
 
2574
struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
 
2575
                                          struct btrfs_root *root,
 
2576
                                          struct btrfs_path *path, u64 dir,
 
2577
                                          const char *name, u16 name_len,
 
2578
                                          int mod);
 
2579
int verify_dir_item(struct btrfs_root *root,
 
2580
                    struct extent_buffer *leaf,
 
2581
                    struct btrfs_dir_item *dir_item);
 
2582
 
 
2583
/* orphan.c */
 
2584
int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
 
2585
                             struct btrfs_root *root, u64 offset);
 
2586
int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
 
2587
                          struct btrfs_root *root, u64 offset);
 
2588
int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
 
2589
 
 
2590
/* inode-item.c */
 
2591
int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
 
2592
                           struct btrfs_root *root,
 
2593
                           const char *name, int name_len,
 
2594
                           u64 inode_objectid, u64 ref_objectid, u64 index);
 
2595
int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
 
2596
                           struct btrfs_root *root,
 
2597
                           const char *name, int name_len,
 
2598
                           u64 inode_objectid, u64 ref_objectid, u64 *index);
 
2599
struct btrfs_inode_ref *
 
2600
btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
 
2601
                        struct btrfs_root *root,
 
2602
                        struct btrfs_path *path,
 
2603
                        const char *name, int name_len,
 
2604
                        u64 inode_objectid, u64 ref_objectid, int mod);
 
2605
int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
 
2606
                             struct btrfs_root *root,
 
2607
                             struct btrfs_path *path, u64 objectid);
 
2608
int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
 
2609
                       *root, struct btrfs_path *path,
 
2610
                       struct btrfs_key *location, int mod);
 
2611
 
 
2612
/* file-item.c */
 
2613
int btrfs_del_csums(struct btrfs_trans_handle *trans,
 
2614
                    struct btrfs_root *root, u64 bytenr, u64 len);
 
2615
int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
 
2616
                          struct bio *bio, u32 *dst);
 
2617
int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
 
2618
                              struct bio *bio, u64 logical_offset, u32 *dst);
 
2619
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
 
2620
                             struct btrfs_root *root,
 
2621
                             u64 objectid, u64 pos,
 
2622
                             u64 disk_offset, u64 disk_num_bytes,
 
2623
                             u64 num_bytes, u64 offset, u64 ram_bytes,
 
2624
                             u8 compression, u8 encryption, u16 other_encoding);
 
2625
int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 
2626
                             struct btrfs_root *root,
 
2627
                             struct btrfs_path *path, u64 objectid,
 
2628
                             u64 bytenr, int mod);
 
2629
int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
 
2630
                           struct btrfs_root *root,
 
2631
                           struct btrfs_ordered_sum *sums);
 
2632
int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
 
2633
                       struct bio *bio, u64 file_start, int contig);
 
2634
struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
 
2635
                                          struct btrfs_root *root,
 
2636
                                          struct btrfs_path *path,
 
2637
                                          u64 bytenr, int cow);
 
2638
int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
 
2639
                        struct btrfs_root *root, struct btrfs_path *path,
 
2640
                        u64 isize);
 
2641
int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
 
2642
                             struct list_head *list, int search_commit);
 
2643
/* inode.c */
 
2644
struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
 
2645
                                           size_t pg_offset, u64 start, u64 len,
 
2646
                                           int create);
 
2647
 
 
2648
/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
 
2649
#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
 
2650
#define ClearPageChecked ClearPageFsMisc
 
2651
#define SetPageChecked SetPageFsMisc
 
2652
#define PageChecked PageFsMisc
 
2653
#endif
 
2654
 
 
2655
/* This forces readahead on a given range of bytes in an inode */
 
2656
static inline void btrfs_force_ra(struct address_space *mapping,
 
2657
                                  struct file_ra_state *ra, struct file *file,
 
2658
                                  pgoff_t offset, unsigned long req_size)
 
2659
{
 
2660
        page_cache_sync_readahead(mapping, ra, file, offset, req_size);
 
2661
}
 
2662
 
 
2663
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
 
2664
int btrfs_set_inode_index(struct inode *dir, u64 *index);
 
2665
int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
 
2666
                       struct btrfs_root *root,
 
2667
                       struct inode *dir, struct inode *inode,
 
2668
                       const char *name, int name_len);
 
2669
int btrfs_add_link(struct btrfs_trans_handle *trans,
 
2670
                   struct inode *parent_inode, struct inode *inode,
 
2671
                   const char *name, int name_len, int add_backref, u64 index);
 
2672
int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
 
2673
                        struct btrfs_root *root,
 
2674
                        struct inode *dir, u64 objectid,
 
2675
                        const char *name, int name_len);
 
2676
int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
 
2677
                               struct btrfs_root *root,
 
2678
                               struct inode *inode, u64 new_size,
 
2679
                               u32 min_type);
 
2680
 
 
2681
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
 
2682
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
 
2683
                              struct extent_state **cached_state);
 
2684
int btrfs_writepages(struct address_space *mapping,
 
2685
                     struct writeback_control *wbc);
 
2686
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
 
2687
                             struct btrfs_root *new_root, u64 new_dirid);
 
2688
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
 
2689
                         size_t size, struct bio *bio, unsigned long bio_flags);
 
2690
 
 
2691
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
 
2692
int btrfs_readpage(struct file *file, struct page *page);
 
2693
void btrfs_evict_inode(struct inode *inode);
 
2694
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
 
2695
int btrfs_dirty_inode(struct inode *inode);
 
2696
int btrfs_update_time(struct file *file);
 
2697
struct inode *btrfs_alloc_inode(struct super_block *sb);
 
2698
void btrfs_destroy_inode(struct inode *inode);
 
2699
int btrfs_drop_inode(struct inode *inode);
 
2700
int btrfs_init_cachep(void);
 
2701
void btrfs_destroy_cachep(void);
 
2702
long btrfs_ioctl_trans_end(struct file *file);
 
2703
struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
 
2704
                         struct btrfs_root *root, int *was_new);
 
2705
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
 
2706
                                    size_t pg_offset, u64 start, u64 end,
 
2707
                                    int create);
 
2708
int btrfs_update_inode(struct btrfs_trans_handle *trans,
 
2709
                              struct btrfs_root *root,
 
2710
                              struct inode *inode);
 
2711
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
 
2712
int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
 
2713
int btrfs_orphan_cleanup(struct btrfs_root *root);
 
2714
void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
 
2715
                              struct btrfs_root *root);
 
2716
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
 
2717
int btrfs_invalidate_inodes(struct btrfs_root *root);
 
2718
void btrfs_add_delayed_iput(struct inode *inode);
 
2719
void btrfs_run_delayed_iputs(struct btrfs_root *root);
 
2720
int btrfs_prealloc_file_range(struct inode *inode, int mode,
 
2721
                              u64 start, u64 num_bytes, u64 min_size,
 
2722
                              loff_t actual_len, u64 *alloc_hint);
 
2723
int btrfs_prealloc_file_range_trans(struct inode *inode,
 
2724
                                    struct btrfs_trans_handle *trans, int mode,
 
2725
                                    u64 start, u64 num_bytes, u64 min_size,
 
2726
                                    loff_t actual_len, u64 *alloc_hint);
 
2727
extern const struct dentry_operations btrfs_dentry_operations;
 
2728
 
 
2729
/* ioctl.c */
 
2730
long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 
2731
void btrfs_update_iflags(struct inode *inode);
 
2732
void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
 
2733
int btrfs_defrag_file(struct inode *inode, struct file *file,
 
2734
                      struct btrfs_ioctl_defrag_range_args *range,
 
2735
                      u64 newer_than, unsigned long max_pages);
 
2736
/* file.c */
 
2737
int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
 
2738
                           struct inode *inode);
 
2739
int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
 
2740
int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
 
2741
int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
 
2742
                            int skip_pinned);
 
2743
extern const struct file_operations btrfs_file_operations;
 
2744
int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
 
2745
                       u64 start, u64 end, u64 *hint_byte, int drop_cache);
 
2746
int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 
2747
                              struct inode *inode, u64 start, u64 end);
 
2748
int btrfs_release_file(struct inode *inode, struct file *file);
 
2749
void btrfs_drop_pages(struct page **pages, size_t num_pages);
 
2750
int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
 
2751
                      struct page **pages, size_t num_pages,
 
2752
                      loff_t pos, size_t write_bytes,
 
2753
                      struct extent_state **cached);
 
2754
 
 
2755
/* tree-defrag.c */
 
2756
int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
 
2757
                        struct btrfs_root *root, int cache_only);
 
2758
 
 
2759
/* sysfs.c */
 
2760
int btrfs_init_sysfs(void);
 
2761
void btrfs_exit_sysfs(void);
 
2762
 
 
2763
/* xattr.c */
 
2764
ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 
2765
 
 
2766
/* super.c */
 
2767
int btrfs_parse_options(struct btrfs_root *root, char *options);
 
2768
int btrfs_sync_fs(struct super_block *sb, int wait);
 
2769
void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
 
2770
                     unsigned int line, int errno);
 
2771
 
 
2772
#define btrfs_std_error(fs_info, errno)                         \
 
2773
do {                                                            \
 
2774
        if ((errno))                                            \
 
2775
                __btrfs_std_error((fs_info), __func__, __LINE__, (errno));\
 
2776
} while (0)
 
2777
 
 
2778
/* acl.c */
 
2779
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
 
2780
struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
 
2781
int btrfs_init_acl(struct btrfs_trans_handle *trans,
 
2782
                   struct inode *inode, struct inode *dir);
 
2783
int btrfs_acl_chmod(struct inode *inode);
 
2784
#else
 
2785
#define btrfs_get_acl NULL
 
2786
static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
 
2787
                                 struct inode *inode, struct inode *dir)
 
2788
{
 
2789
        return 0;
 
2790
}
 
2791
static inline int btrfs_acl_chmod(struct inode *inode)
 
2792
{
 
2793
        return 0;
 
2794
}
 
2795
#endif
 
2796
 
 
2797
/* relocation.c */
 
2798
int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
 
2799
int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
 
2800
                          struct btrfs_root *root);
 
2801
int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
 
2802
                            struct btrfs_root *root);
 
2803
int btrfs_recover_relocation(struct btrfs_root *root);
 
2804
int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
 
2805
void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
 
2806
                           struct btrfs_root *root, struct extent_buffer *buf,
 
2807
                           struct extent_buffer *cow);
 
2808
void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
 
2809
                              struct btrfs_pending_snapshot *pending,
 
2810
                              u64 *bytes_to_reserve);
 
2811
void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
 
2812
                              struct btrfs_pending_snapshot *pending);
 
2813
 
 
2814
/* scrub.c */
 
2815
int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
 
2816
                    struct btrfs_scrub_progress *progress, int readonly);
 
2817
int btrfs_scrub_pause(struct btrfs_root *root);
 
2818
int btrfs_scrub_pause_super(struct btrfs_root *root);
 
2819
int btrfs_scrub_continue(struct btrfs_root *root);
 
2820
int btrfs_scrub_continue_super(struct btrfs_root *root);
 
2821
int btrfs_scrub_cancel(struct btrfs_root *root);
 
2822
int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev);
 
2823
int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid);
 
2824
int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
 
2825
                         struct btrfs_scrub_progress *progress);
 
2826
 
 
2827
/* reada.c */
 
2828
struct reada_control {
 
2829
        struct btrfs_root       *root;          /* tree to prefetch */
 
2830
        struct btrfs_key        key_start;
 
2831
        struct btrfs_key        key_end;        /* exclusive */
 
2832
        atomic_t                elems;
 
2833
        struct kref             refcnt;
 
2834
        wait_queue_head_t       wait;
 
2835
};
 
2836
struct reada_control *btrfs_reada_add(struct btrfs_root *root,
 
2837
                              struct btrfs_key *start, struct btrfs_key *end);
 
2838
int btrfs_reada_wait(void *handle);
 
2839
void btrfs_reada_detach(void *handle);
 
2840
int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,
 
2841
                         u64 start, int err);
 
2842
 
 
2843
#endif