ctree.h 126.0 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

C
Chris Mason 已提交
19 20
#ifndef __BTRFS_CTREE__
#define __BTRFS_CTREE__
21

22 23
#include <linux/mm.h>
#include <linux/highmem.h>
C
Chris Mason 已提交
24
#include <linux/fs.h>
A
Arne Jansen 已提交
25
#include <linux/rwsem.h>
S
Stefan Behrens 已提交
26
#include <linux/semaphore.h>
27
#include <linux/completion.h>
C
Chris Mason 已提交
28
#include <linux/backing-dev.h>
29
#include <linux/wait.h>
30
#include <linux/slab.h>
S
Stefan Schmidt 已提交
31
#include <linux/kobject.h>
32
#include <trace/events/btrfs.h>
33
#include <asm/kmap_types.h>
34
#include <linux/pagemap.h>
35
#include <linux/btrfs.h>
36
#include <linux/btrfs_tree.h>
37
#include <linux/workqueue.h>
38
#include <linux/security.h>
39
#include <linux/sizes.h>
J
Jeff Mahoney 已提交
40
#include <linux/dynamic_debug.h>
41
#include "extent_io.h"
42
#include "extent_map.h"
43
#include "async-thread.h"
C
Chris Mason 已提交
44

45
struct btrfs_trans_handle;
C
Chris Mason 已提交
46
struct btrfs_transaction;
47
struct btrfs_pending_snapshot;
C
Chris Mason 已提交
48 49 50
extern struct kmem_cache *btrfs_trans_handle_cachep;
extern struct kmem_cache *btrfs_transaction_cachep;
extern struct kmem_cache *btrfs_bit_radix_cachep;
C
Chris Mason 已提交
51
extern struct kmem_cache *btrfs_path_cachep;
52
extern struct kmem_cache *btrfs_free_space_cachep;
53
struct btrfs_ordered_sum;
54

55 56 57 58 59 60
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
#define STATIC noinline
#else
#define STATIC static noinline
#endif

61
#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
62

63
#define BTRFS_MAX_MIRRORS 3
64

65
#define BTRFS_MAX_LEVEL 8
66

67 68
#define BTRFS_COMPAT_EXTENT_TREE_V0

69 70 71 72 73 74
/*
 * the max metadata block size.  This limit is somewhat artificial,
 * but the memmove costs go through the roof for larger blocks.
 */
#define BTRFS_MAX_METADATA_BLOCKSIZE 65536

C
Chris Mason 已提交
75 76 77 78 79 80
/*
 * we can actually store much bigger names, but lets not confuse the rest
 * of linux
 */
#define BTRFS_NAME_LEN 255

M
Mark Fasheh 已提交
81 82 83 84 85 86 87
/*
 * Theoretical limit is larger, but we keep this down to a sane
 * value. That should limit greatly the possibility of collisions on
 * inode ref items.
 */
#define BTRFS_LINK_MAX 65535U

D
David Sterba 已提交
88
static const int btrfs_csum_sizes[] = { 4 };
89

90
/* four bytes for CRC32 */
91
#define BTRFS_EMPTY_DIR_SIZE 0
C
Chris Mason 已提交
92

93 94 95
/* ioprio of readahead is set to idle */
#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))

96
#define BTRFS_DIRTY_METADATA_THRESH	SZ_32M
97

98
#define BTRFS_MAX_EXTENT_SIZE SZ_128M
99

100 101 102 103 104 105 106 107
/*
 * Count how many BTRFS_MAX_EXTENT_SIZE cover the @size
 */
static inline u32 count_max_extents(u64 size)
{
	return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
}

108 109 110 111 112 113 114 115 116 117 118
struct btrfs_mapping_tree {
	struct extent_map_tree map_tree;
};

static inline unsigned long btrfs_chunk_item_size(int num_stripes)
{
	BUG_ON(num_stripes == 0);
	return sizeof(struct btrfs_chunk) +
		sizeof(struct btrfs_stripe) * (num_stripes - 1);
}

L
liubo 已提交
119 120 121
/*
 * File system states
 */
122
#define BTRFS_FS_STATE_ERROR		0
M
Miao Xie 已提交
123
#define BTRFS_FS_STATE_REMOUNTING	1
124
#define BTRFS_FS_STATE_TRANS_ABORTED	2
125
#define BTRFS_FS_STATE_DEV_REPLACING	3
126
#define BTRFS_FS_STATE_DUMMY_FS_INFO	4
L
liubo 已提交
127

128 129 130 131 132 133 134
#define BTRFS_BACKREF_REV_MAX		256
#define BTRFS_BACKREF_REV_SHIFT		56
#define BTRFS_BACKREF_REV_MASK		(((u64)BTRFS_BACKREF_REV_MAX - 1) << \
					 BTRFS_BACKREF_REV_SHIFT)

#define BTRFS_OLD_BACKREF_REV		0
#define BTRFS_MIXED_BACKREF_REV		1
135

136 137 138
/*
 * every tree block (leaf or node) starts with this header.
 */
139
struct btrfs_header {
140
	/* these first four must match the super block */
C
Chris Mason 已提交
141
	u8 csum[BTRFS_CSUM_SIZE];
142
	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
143
	__le64 bytenr; /* which block this node is supposed to live in */
144
	__le64 flags;
145 146 147

	/* allowed to be different from the super from here on down */
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
148
	__le64 generation;
149
	__le64 owner;
150
	__le32 nritems;
151
	u8 level;
152 153
} __attribute__ ((__packed__));

154 155 156 157 158 159
/*
 * this is a very generous portion of the super block, giving us
 * room to translate 14 chunks with 3 stripes each.
 */
#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048

C
Chris Mason 已提交
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
/*
 * just in case we somehow lose the roots and are not able to mount,
 * we store an array of the roots from previous transactions
 * in the super.
 */
#define BTRFS_NUM_BACKUP_ROOTS 4
struct btrfs_root_backup {
	__le64 tree_root;
	__le64 tree_root_gen;

	__le64 chunk_root;
	__le64 chunk_root_gen;

	__le64 extent_root;
	__le64 extent_root_gen;

	__le64 fs_root;
	__le64 fs_root_gen;

	__le64 dev_root;
	__le64 dev_root_gen;

	__le64 csum_root;
	__le64 csum_root_gen;

	__le64 total_bytes;
	__le64 bytes_used;
	__le64 num_devices;
	/* future */
M
Masanari Iida 已提交
189
	__le64 unused_64[4];
C
Chris Mason 已提交
190 191 192 193 194 195 196 197 198 199 200

	u8 tree_root_level;
	u8 chunk_root_level;
	u8 extent_root_level;
	u8 fs_root_level;
	u8 dev_root_level;
	u8 csum_root_level;
	/* future and to align */
	u8 unused_8[10];
} __attribute__ ((__packed__));

201 202 203 204
/*
 * the super block basically lists the main trees of the FS
 * it currently lacks any block count etc etc
 */
C
Chris Mason 已提交
205
struct btrfs_super_block {
C
Chris Mason 已提交
206
	u8 csum[BTRFS_CSUM_SIZE];
207
	/* the first 4 fields must match struct btrfs_header */
Y
Yan Zheng 已提交
208
	u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
209
	__le64 bytenr; /* this block number */
210
	__le64 flags;
211 212

	/* allowed to be different from the btrfs_header from here own down */
213 214 215
	__le64 magic;
	__le64 generation;
	__le64 root;
216
	__le64 chunk_root;
217
	__le64 log_root;
218 219 220

	/* this will help find the new super based on the log root */
	__le64 log_root_transid;
221 222
	__le64 total_bytes;
	__le64 bytes_used;
223
	__le64 root_dir_objectid;
224
	__le64 num_devices;
225 226
	__le32 sectorsize;
	__le32 nodesize;
227
	__le32 __unused_leafsize;
228
	__le32 stripesize;
229
	__le32 sys_chunk_array_size;
230
	__le64 chunk_root_generation;
231 232 233
	__le64 compat_flags;
	__le64 compat_ro_flags;
	__le64 incompat_flags;
234
	__le16 csum_type;
235
	u8 root_level;
236
	u8 chunk_root_level;
237
	u8 log_root_level;
238
	struct btrfs_dev_item dev_item;
239

240
	char label[BTRFS_LABEL_SIZE];
241

242
	__le64 cache_generation;
243
	__le64 uuid_tree_generation;
244

245
	/* future expansion */
246
	__le64 reserved[30];
247
	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
C
Chris Mason 已提交
248
	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
C
Chris Mason 已提交
249 250
} __attribute__ ((__packed__));

251 252 253 254
/*
 * Compat flags that we support.  If any incompat flags are set other than the
 * ones specified below then we will fail to mount
 */
255
#define BTRFS_FEATURE_COMPAT_SUPP		0ULL
256 257
#define BTRFS_FEATURE_COMPAT_SAFE_SET		0ULL
#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR		0ULL
258 259

#define BTRFS_FEATURE_COMPAT_RO_SUPP			\
260 261
	(BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |	\
	 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
262

263 264 265
#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET	0ULL
#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR	0ULL

266 267
#define BTRFS_FEATURE_INCOMPAT_SUPP			\
	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\
268
	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\
L
Li Zefan 已提交
269
	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |		\
270
	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
M
Mark Fasheh 已提交
271
	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
D
David Woodhouse 已提交
272
	 BTRFS_FEATURE_INCOMPAT_RAID56 |		\
273
	 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |		\
274 275
	 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |	\
	 BTRFS_FEATURE_INCOMPAT_NO_HOLES)
276

277 278 279
#define BTRFS_FEATURE_INCOMPAT_SAFE_SET			\
	(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR		0ULL
280

281
/*
282
 * A leaf is full of items. offset and size tell us where to find
283 284
 * the item in the leaf (relative to the start of the data area)
 */
C
Chris Mason 已提交
285
struct btrfs_item {
C
Chris Mason 已提交
286
	struct btrfs_disk_key key;
C
Chris Mason 已提交
287
	__le32 offset;
288
	__le32 size;
289 290
} __attribute__ ((__packed__));

291 292 293 294 295 296 297
/*
 * leaves have an item area and a data area:
 * [item0, item1....itemN] [free space] [dataN...data1, data0]
 *
 * The data is separate from the items to get the keys closer together
 * during searches.
 */
C
Chris Mason 已提交
298
struct btrfs_leaf {
299
	struct btrfs_header header;
C
Chris Mason 已提交
300
	struct btrfs_item items[];
301 302
} __attribute__ ((__packed__));

303 304 305 306
/*
 * all non-leaf blocks are nodes, they hold only keys and pointers to
 * other blocks
 */
C
Chris Mason 已提交
307 308 309
struct btrfs_key_ptr {
	struct btrfs_disk_key key;
	__le64 blockptr;
310
	__le64 generation;
C
Chris Mason 已提交
311 312
} __attribute__ ((__packed__));

C
Chris Mason 已提交
313
struct btrfs_node {
314
	struct btrfs_header header;
C
Chris Mason 已提交
315
	struct btrfs_key_ptr ptrs[];
316 317
} __attribute__ ((__packed__));

318
/*
C
Chris Mason 已提交
319 320
 * btrfs_paths remember the path taken from the root down to the leaf.
 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
321 322 323 324 325
 * to any other levels that are present.
 *
 * The slots array records the index of the item or block pointer
 * used while walking the tree.
 */
326
enum { READA_NONE = 0, READA_BACK, READA_FORWARD };
C
Chris Mason 已提交
327
struct btrfs_path {
328
	struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
C
Chris Mason 已提交
329
	int slots[BTRFS_MAX_LEVEL];
330
	/* if there is real range locking, this locks field will change */
331
	u8 locks[BTRFS_MAX_LEVEL];
332
	u8 reada;
333
	/* keep some upper locks as we walk down */
334
	u8 lowest_level;
335 336 337 338 339

	/*
	 * set by btrfs_split_item, tells search_slot to keep all locks
	 * and to force calls to keep space in the nodes
	 */
340 341 342 343
	unsigned int search_for_split:1;
	unsigned int keep_locks:1;
	unsigned int skip_locking:1;
	unsigned int leave_spinning:1;
344
	unsigned int search_commit_root:1;
345
	unsigned int need_commit_sem:1;
346
	unsigned int skip_release_on_error:1;
347
};
348
#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
349
					sizeof(struct btrfs_item))
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
struct btrfs_dev_replace {
	u64 replace_state;	/* see #define above */
	u64 time_started;	/* seconds since 1-Jan-1970 */
	u64 time_stopped;	/* seconds since 1-Jan-1970 */
	atomic64_t num_write_errors;
	atomic64_t num_uncorrectable_read_errors;

	u64 cursor_left;
	u64 committed_cursor_left;
	u64 cursor_left_last_write_of_item;
	u64 cursor_right;

	u64 cont_reading_from_srcdev_mode;	/* see #define above */

	int is_valid;
	int item_needs_writeback;
	struct btrfs_device *srcdev;
	struct btrfs_device *tgtdev;

	pid_t lock_owner;
	atomic_t nesting_level;
	struct mutex lock_finishing_cancel_unmount;
372 373 374 375
	rwlock_t lock;
	atomic_t read_locks;
	atomic_t blocking_readers;
	wait_queue_head_t read_lock_wq;
376 377 378 379

	struct btrfs_scrub_progress scrub_progress;
};

380 381 382 383 384 385
/* For raid type sysfs entries */
struct raid_kobject {
	int raid_type;
	struct kobject kobj;
};

386
struct btrfs_space_info {
387
	spinlock_t lock;
J
Josef Bacik 已提交
388

J
Josef Bacik 已提交
389 390
	u64 total_bytes;	/* total bytes in the space,
				   this doesn't take mirrors into account */
391
	u64 bytes_used;		/* total bytes used,
392
				   this doesn't take mirrors into account */
J
Josef Bacik 已提交
393 394 395 396 397
	u64 bytes_pinned;	/* total bytes pinned, will be freed when the
				   transaction finishes */
	u64 bytes_reserved;	/* total bytes the allocator has reserved for
				   current allocations */
	u64 bytes_may_use;	/* number of bytes that may be used for
J
Josef Bacik 已提交
398
				   delalloc/allocations */
399 400
	u64 bytes_readonly;	/* total bytes that are read only */

401 402 403 404
	u64 max_extent_size;	/* This will hold the maximum extent size of
				   the space info if we had an ENOSPC in the
				   allocator. */

405 406 407 408 409 410 411 412 413
	unsigned int full:1;	/* indicates that we cannot allocate any more
				   chunks for this space */
	unsigned int chunk_alloc:1;	/* set if we are allocating a chunk */

	unsigned int flush:1;		/* set if we are trying to make space */

	unsigned int force_alloc;	/* set if we need to force a chunk
					   alloc for this space */

414
	u64 disk_used;		/* total bytes used on disk */
J
Josef Bacik 已提交
415 416
	u64 disk_total;		/* total bytes on disk, takes mirrors into
				   account */
J
Josef Bacik 已提交
417

418 419
	u64 flags;

420 421 422 423 424
	/*
	 * bytes_pinned is kept in line with what is actually pinned, as in
	 * we've called update_block_group and dropped the bytes_used counter
	 * and increased the bytes_pinned counter.  However this means that
	 * bytes_pinned does not reflect the bytes that will be pinned once the
425 426
	 * delayed refs are flushed, so this counter is inc'ed every time we
	 * call btrfs_free_extent so it is a realtime count of what will be
427
	 * freed once the transaction is committed.  It will be zeroed every
428
	 * time the transaction commits.
429 430 431
	 */
	struct percpu_counter total_bytes_pinned;

432
	struct list_head list;
433
	/* Protected by the spinlock 'lock'. */
434
	struct list_head ro_bgs;
435 436
	struct list_head priority_tickets;
	struct list_head tickets;
437 438 439 440
	/*
	 * tickets_id just indicates the next ticket will be handled, so note
	 * it's not stored per ticket.
	 */
441
	u64 tickets_id;
J
Josef Bacik 已提交
442

443
	struct rw_semaphore groups_sem;
J
Josef Bacik 已提交
444
	/* for block groups in our same type */
445
	struct list_head block_groups[BTRFS_NR_RAID_TYPES];
446
	wait_queue_head_t wait;
447 448

	struct kobject kobj;
449
	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
J
Josef Bacik 已提交
450 451
};

452 453 454 455 456 457 458 459
#define	BTRFS_BLOCK_RSV_GLOBAL		1
#define	BTRFS_BLOCK_RSV_DELALLOC	2
#define	BTRFS_BLOCK_RSV_TRANS		3
#define	BTRFS_BLOCK_RSV_CHUNK		4
#define	BTRFS_BLOCK_RSV_DELOPS		5
#define	BTRFS_BLOCK_RSV_EMPTY		6
#define	BTRFS_BLOCK_RSV_TEMP		7

460 461 462 463 464
struct btrfs_block_rsv {
	u64 size;
	u64 reserved;
	struct btrfs_space_info *space_info;
	spinlock_t lock;
465 466 467
	unsigned short full;
	unsigned short type;
	unsigned short failfast;
468 469
};

470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
/*
 * free clusters are used to claim free space in relatively large chunks,
 * allowing us to do less seeky writes.  They are used for all metadata
 * allocations and data allocations in ssd mode.
 */
struct btrfs_free_cluster {
	spinlock_t lock;
	spinlock_t refill_lock;
	struct rb_root root;

	/* largest extent in this cluster */
	u64 max_size;

	/* first extent starting offset */
	u64 window_start;

486 487 488
	/* We did a full search and couldn't create a cluster */
	bool fragmented;

489 490 491 492 493 494 495
	struct btrfs_block_group_cache *block_group;
	/*
	 * when a cluster is allocated from a block group, we put the
	 * cluster onto a list in the block group so that it can
	 * be freed before the block group is freed.
	 */
	struct list_head block_group_list;
496 497
};

J
Josef Bacik 已提交
498 499 500
enum btrfs_caching_type {
	BTRFS_CACHE_NO		= 0,
	BTRFS_CACHE_STARTED	= 1,
501 502
	BTRFS_CACHE_FAST	= 2,
	BTRFS_CACHE_FINISHED	= 3,
503
	BTRFS_CACHE_ERROR	= 4,
J
Josef Bacik 已提交
504 505
};

506 507 508 509 510 511 512
enum btrfs_disk_cache_state {
	BTRFS_DC_WRITTEN	= 0,
	BTRFS_DC_ERROR		= 1,
	BTRFS_DC_CLEAR		= 2,
	BTRFS_DC_SETUP		= 3,
};

513 514 515 516
struct btrfs_caching_control {
	struct list_head list;
	struct mutex mutex;
	wait_queue_head_t wait;
517
	struct btrfs_work work;
518 519 520 521 522
	struct btrfs_block_group_cache *block_group;
	u64 progress;
	atomic_t count;
};

O
Omar Sandoval 已提交
523 524 525
/* Once caching_thread() finds this much free space, it will wake up waiters. */
#define CACHING_CTL_WAKE_UP (1024 * 1024 * 2)

526 527 528 529
struct btrfs_io_ctl {
	void *cur, *orig;
	struct page *page;
	struct page **pages;
530
	struct btrfs_fs_info *fs_info;
531
	struct inode *inode;
532 533 534
	unsigned long size;
	int index;
	int num_pages;
535 536
	int entries;
	int bitmaps;
537 538 539
	unsigned check_crcs:1;
};

C
Chris Mason 已提交
540 541 542
struct btrfs_block_group_cache {
	struct btrfs_key key;
	struct btrfs_block_group_item item;
J
Josef Bacik 已提交
543
	struct btrfs_fs_info *fs_info;
544
	struct inode *inode;
545
	spinlock_t lock;
546
	u64 pinned;
547
	u64 reserved;
548
	u64 delalloc_bytes;
549
	u64 bytes_super;
550
	u64 flags;
551
	u64 cache_generation;
552 553 554 555 556 557 558 559 560 561 562 563 564
	u32 sectorsize;

	/*
	 * If the free space extent count exceeds this number, convert the block
	 * group to bitmaps.
	 */
	u32 bitmap_high_thresh;

	/*
	 * If the free space extent count drops below this number, convert the
	 * block group back to extents.
	 */
	u32 bitmap_low_thresh;
D
David Woodhouse 已提交
565

566 567 568 569 570 571 572
	/*
	 * It is just used for the delayed data space allocation because
	 * only the data space allocation and the relative metadata update
	 * can be done cross the transaction.
	 */
	struct rw_semaphore data_rwsem;

D
David Woodhouse 已提交
573 574 575
	/* for raid56, this is a full stripe, without parity */
	unsigned long full_stripe_len;

576
	unsigned int ro;
577
	unsigned int iref:1;
578
	unsigned int has_caching_ctl:1;
579
	unsigned int removed:1;
580 581

	int disk_cache_state;
J
Josef Bacik 已提交
582

J
Josef Bacik 已提交
583 584
	/* cache tracking stuff */
	int cached;
585 586
	struct btrfs_caching_control *caching_ctl;
	u64 last_byte_to_unpin;
J
Josef Bacik 已提交
587

J
Josef Bacik 已提交
588 589 590
	struct btrfs_space_info *space_info;

	/* free space cache stuff */
591
	struct btrfs_free_space_ctl *free_space_ctl;
J
Josef Bacik 已提交
592 593 594 595 596 597

	/* block group cache stuff */
	struct rb_node cache_node;

	/* for block groups in the same raid type */
	struct list_head list;
598 599 600

	/* usage count */
	atomic_t count;
601 602 603 604 605

	/* List of struct btrfs_free_clusters for this block group.
	 * Today it will only have one thing on it, but that may change
	 */
	struct list_head cluster_list;
606

607 608
	/* For delayed block group creation or deletion of empty block groups */
	struct list_head bg_list;
609 610 611

	/* For read-only block groups */
	struct list_head ro_list;
612 613

	atomic_t trimming;
614 615 616

	/* For dirty block groups */
	struct list_head dirty_list;
617 618 619
	struct list_head io_list;

	struct btrfs_io_ctl io_ctl;
620

621 622 623 624 625 626 627 628 629 630 631
	/*
	 * Incremented when doing extent allocations and holding a read lock
	 * on the space_info's groups_sem semaphore.
	 * Decremented when an ordered extent that represents an IO against this
	 * block group's range is created (after it's added to its inode's
	 * root's list of ordered extents) or immediately after the allocation
	 * if it's a metadata extent or fallocate extent (for these cases we
	 * don't create ordered extents).
	 */
	atomic_t reservations;

632 633 634 635 636 637 638 639 640 641
	/*
	 * Incremented while holding the spinlock *lock* by a task checking if
	 * it can perform a nocow write (incremented if the value for the *ro*
	 * field is 0). Decremented by such tasks once they create an ordered
	 * extent or before that if some error happens before reaching that step.
	 * This is to prevent races between block group relocation and nocow
	 * writes through direct IO.
	 */
	atomic_t nocow_writers;

642 643 644 645 646 647 648 649
	/* Lock for free space tree operations. */
	struct mutex free_space_lock;

	/*
	 * Does the block group need to be added to the free space tree?
	 * Protected by free_space_lock.
	 */
	int needs_free_space;
C
Chris Mason 已提交
650
};
651

652 653 654 655 656 657
/* delayed seq elem */
struct seq_list {
	struct list_head list;
	u64 seq;
};

658 659
#define SEQ_LIST_INIT(name)	{ .list = LIST_HEAD_INIT((name).list), .seq = 0 }

660 661 662 663 664
enum btrfs_orphan_cleanup_state {
	ORPHAN_CLEANUP_STARTED	= 1,
	ORPHAN_CLEANUP_DONE	= 2,
};

D
David Woodhouse 已提交
665 666 667 668 669 670 671 672 673
/* used by the raid56 code to lock stripes for read/modify/write */
struct btrfs_stripe_hash {
	struct list_head hash_list;
	wait_queue_head_t wait;
	spinlock_t lock;
};

/* used by the raid56 code to lock stripes for read/modify/write */
struct btrfs_stripe_hash_table {
674 675 676 677
	struct list_head stripe_cache;
	spinlock_t cache_lock;
	int cache_size;
	struct btrfs_stripe_hash table[];
D
David Woodhouse 已提交
678 679 680 681
};

#define BTRFS_STRIPE_HASH_TABLE_BITS 11

682 683
void btrfs_init_async_reclaim_work(struct work_struct *work);

684
/* fs_info */
685
struct reloc_control;
686
struct btrfs_device;
687
struct btrfs_fs_devices;
688
struct btrfs_balance_control;
689
struct btrfs_delayed_root;
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704

#define BTRFS_FS_BARRIER			1
#define BTRFS_FS_CLOSING_START			2
#define BTRFS_FS_CLOSING_DONE			3
#define BTRFS_FS_LOG_RECOVERING			4
#define BTRFS_FS_OPEN				5
#define BTRFS_FS_QUOTA_ENABLED			6
#define BTRFS_FS_QUOTA_ENABLING			7
#define BTRFS_FS_QUOTA_DISABLING		8
#define BTRFS_FS_UPDATE_UUID_TREE_GEN		9
#define BTRFS_FS_CREATING_FREE_SPACE_TREE	10
#define BTRFS_FS_BTREE_ERR			11
#define BTRFS_FS_LOG1_ERR			12
#define BTRFS_FS_LOG2_ERR			13

705
struct btrfs_fs_info {
706
	u8 fsid[BTRFS_FSID_SIZE];
707
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
708
	unsigned long flags;
709 710
	struct btrfs_root *extent_root;
	struct btrfs_root *tree_root;
711 712
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
713
	struct btrfs_root *fs_root;
714
	struct btrfs_root *csum_root;
715
	struct btrfs_root *quota_root;
716
	struct btrfs_root *uuid_root;
717
	struct btrfs_root *free_space_root;
718 719 720

	/* the log root tree is a directory of all the other log roots */
	struct btrfs_root *log_root_tree;
721 722

	spinlock_t fs_roots_radix_lock;
723
	struct radix_tree_root fs_roots_radix;
724

J
Josef Bacik 已提交
725 726
	/* block group cache stuff */
	spinlock_t block_group_cache_lock;
727
	u64 first_logical_byte;
J
Josef Bacik 已提交
728 729
	struct rb_root block_group_cache_tree;

730 731 732 733
	/* keep track of unallocated space */
	spinlock_t free_chunk_lock;
	u64 free_chunk_space;

734 735
	struct extent_io_tree freed_extents[2];
	struct extent_io_tree *pinned_extents;
736

737 738 739
	/* logical->physical extent mapping */
	struct btrfs_mapping_tree mapping_tree;

740 741 742 743
	/*
	 * block reservation for extent, checksum, root tree and
	 * delayed dir index item
	 */
744 745 746 747 748 749 750
	struct btrfs_block_rsv global_block_rsv;
	/* block reservation for delay allocation */
	struct btrfs_block_rsv delalloc_block_rsv;
	/* block reservation for metadata operations */
	struct btrfs_block_rsv trans_block_rsv;
	/* block reservation for chunk tree */
	struct btrfs_block_rsv chunk_block_rsv;
751 752
	/* block reservation for delayed operations */
	struct btrfs_block_rsv delayed_block_rsv;
753 754 755

	struct btrfs_block_rsv empty_block_rsv;

756
	u64 generation;
757
	u64 last_trans_committed;
758
	u64 avg_delayed_ref_runtime;
759 760 761 762 763 764

	/*
	 * this is updated to the current trans every time a full commit
	 * is required instead of the faster short fsync log commits
	 */
	u64 last_trans_log_full_commit;
765
	unsigned long mount_opt;
766 767 768 769 770
	/*
	 * Track requests for actions that need to be done during transaction
	 * commit (like for some mount options).
	 */
	unsigned long pending_changes;
771
	unsigned long compress_type:4;
772
	int commit_interval;
773 774 775 776 777 778
	/*
	 * It is a suggestive number, the read side is safe even it gets a
	 * wrong number because we will write out the data into a regular
	 * extent. The write side(mount/remount) is under ->s_umount lock,
	 * so it is also safe.
	 */
779
	u64 max_inline;
M
Miao Xie 已提交
780 781 782 783 784 785 786 787 788 789
	/*
	 * Protected by ->chunk_mutex and sb->s_umount.
	 *
	 * The reason that we use two lock to protect it is because only
	 * remount and mount operations can change it and these two operations
	 * are under sb->s_umount, but the read side (chunk allocation) can not
	 * acquire sb->s_umount or the deadlock would happen. So we use two
	 * locks to protect it. On the write side, we must acquire two locks,
	 * and on the read side, we just need acquire one of them.
	 */
790
	u64 alloc_start;
C
Chris Mason 已提交
791
	struct btrfs_transaction *running_transaction;
792
	wait_queue_head_t transaction_throttle;
793
	wait_queue_head_t transaction_wait;
S
Sage Weil 已提交
794
	wait_queue_head_t transaction_blocked_wait;
795
	wait_queue_head_t async_submit_wait;
796

797 798 799 800 801 802 803 804 805 806 807
	/*
	 * Used to protect the incompat_flags, compat_flags, compat_ro_flags
	 * when they are updated.
	 *
	 * Because we do not clear the flags for ever, so we needn't use
	 * the lock on the read side.
	 *
	 * We also needn't use the lock when we mount the fs, because
	 * there is no other task which will update the flag.
	 */
	spinlock_t super_lock;
808 809
	struct btrfs_super_block *super_copy;
	struct btrfs_super_block *super_for_commit;
C
Chris Mason 已提交
810
	struct super_block *sb;
811
	struct inode *btree_inode;
C
Chris Mason 已提交
812
	struct backing_dev_info bdi;
813
	struct mutex tree_log_mutex;
814 815
	struct mutex transaction_kthread_mutex;
	struct mutex cleaner_mutex;
816
	struct mutex chunk_mutex;
817
	struct mutex volume_mutex;
D
David Woodhouse 已提交
818

819 820 821 822 823 824
	/*
	 * this is taken to make sure we don't set block groups ro after
	 * the free space cache has been allocated on them
	 */
	struct mutex ro_block_group_mutex;

D
David Woodhouse 已提交
825 826 827 828 829 830
	/* this is used during read/modify/write to make sure
	 * no two ios are trying to mod the same stripe at the same
	 * time
	 */
	struct btrfs_stripe_hash_table *stripe_hash_table;

831 832 833 834 835 836 837 838
	/*
	 * this protects the ordered operations list only while we are
	 * processing all of the entries on it.  This way we make
	 * sure the commit code doesn't find the list temporarily empty
	 * because another function happens to be doing non-waiting preflush
	 * before jumping into the main commit.
	 */
	struct mutex ordered_operations_mutex;
839

840
	struct rw_semaphore commit_root_sem;
841

842
	struct rw_semaphore cleanup_work_sem;
843

844
	struct rw_semaphore subvol_sem;
845 846
	struct srcu_struct subvol_srcu;

J
Josef Bacik 已提交
847
	spinlock_t trans_lock;
C
Chris Mason 已提交
848 849 850 851 852 853
	/*
	 * the reloc mutex goes with the trans lock, it is taken
	 * during commit to protect us from the relocation code
	 */
	struct mutex reloc_mutex;

C
Chris Mason 已提交
854
	struct list_head trans_list;
855
	struct list_head dead_roots;
856
	struct list_head caching_block_groups;
857

Y
Yan, Zheng 已提交
858 859
	spinlock_t delayed_iput_lock;
	struct list_head delayed_iputs;
860
	struct mutex cleaner_delayed_iput_mutex;
Y
Yan, Zheng 已提交
861

J
Jan Schmidt 已提交
862 863
	/* this protects tree_mod_seq_list */
	spinlock_t tree_mod_seq_lock;
864
	atomic64_t tree_mod_seq;
J
Jan Schmidt 已提交
865 866 867 868 869 870
	struct list_head tree_mod_seq_list;

	/* this protects tree_mod_log */
	rwlock_t tree_mod_log_lock;
	struct rb_root tree_mod_log;

871
	atomic_t nr_async_submits;
872
	atomic_t async_submit_draining;
873
	atomic_t nr_async_bios;
874
	atomic_t async_delalloc_pages;
J
Josef Bacik 已提交
875
	atomic_t open_ioctl_trans;
876

877
	/*
878
	 * this is used to protect the following list -- ordered_roots.
879
	 */
880
	spinlock_t ordered_root_lock;
881 882

	/*
883 884 885
	 * all fs/file tree roots in which there are data=ordered extents
	 * pending writeback are added into this list.
	 *
886 887 888
	 * these can span multiple transactions and basically include
	 * every dirty data page that isn't from nodatacow
	 */
889
	struct list_head ordered_roots;
890

891
	struct mutex delalloc_root_mutex;
892 893 894
	spinlock_t delalloc_root_lock;
	/* all fs/file tree roots that have delalloc inodes. */
	struct list_head delalloc_roots;
895

896 897 898 899 900 901
	/*
	 * there is a pool of worker threads for checksumming during writes
	 * and a pool for checksumming after reads.  This is because readers
	 * can run with FS locks held, and the writers may be waiting for
	 * those locks.  We don't want ordering in the pending list to cause
	 * deadlocks, and so the two are serviced separately.
902 903 904
	 *
	 * A third pool does submit_bio to avoid deadlocking with the other
	 * two
905
	 */
906 907 908 909 910 911
	struct btrfs_workqueue *workers;
	struct btrfs_workqueue *delalloc_workers;
	struct btrfs_workqueue *flush_workers;
	struct btrfs_workqueue *endio_workers;
	struct btrfs_workqueue *endio_meta_workers;
	struct btrfs_workqueue *endio_raid56_workers;
912
	struct btrfs_workqueue *endio_repair_workers;
913 914 915 916 917 918 919
	struct btrfs_workqueue *rmw_workers;
	struct btrfs_workqueue *endio_meta_write_workers;
	struct btrfs_workqueue *endio_write_workers;
	struct btrfs_workqueue *endio_freespace_worker;
	struct btrfs_workqueue *submit_workers;
	struct btrfs_workqueue *caching_workers;
	struct btrfs_workqueue *readahead_workers;
920

921 922 923 924 925
	/*
	 * fixup workers take dirty pages that didn't properly go through
	 * the cow mechanism and make them safe to write.  It happens
	 * for the sys_munmap function call path
	 */
926 927
	struct btrfs_workqueue *fixup_workers;
	struct btrfs_workqueue *delayed_workers;
C
Chris Mason 已提交
928 929 930

	/* the extent workers do delayed refs on the extent allocation tree */
	struct btrfs_workqueue *extent_workers;
931 932
	struct task_struct *transaction_kthread;
	struct task_struct *cleaner_kthread;
933
	int thread_pool_size;
934

935
	struct kobject *space_info_kobj;
936

937
	u64 total_pinned;
938

939 940
	/* used to keep from writing metadata until there is a nice batch */
	struct percpu_counter dirty_metadata_bytes;
941
	struct percpu_counter delalloc_bytes;
942
	s32 dirty_metadata_batch;
943 944
	s32 delalloc_batch;

945 946
	struct list_head dirty_cowonly_roots;

947
	struct btrfs_fs_devices *fs_devices;
948 949 950 951 952 953

	/*
	 * the space_info list is almost entirely read only.  It only changes
	 * when we add a new raid type to the FS, and that happens
	 * very rarely.  RCU is used to protect it.
	 */
954
	struct list_head space_info;
955

956 957
	struct btrfs_space_info *data_sinfo;

958 959
	struct reloc_control *reloc_ctl;

960 961 962 963 964
	/* data_alloc_cluster is only used in ssd mode */
	struct btrfs_free_cluster data_alloc_cluster;

	/* all metadata allocations go through this cluster */
	struct btrfs_free_cluster meta_alloc_cluster;
C
Chris Mason 已提交
965

C
Chris Mason 已提交
966 967 968 969 970
	/* auto defrag inodes go here */
	spinlock_t defrag_inodes_lock;
	struct rb_root defrag_inodes;
	atomic_t defrag_running;

971 972
	/* Used to protect avail_{data, metadata, system}_alloc_bits */
	seqlock_t profiles_lock;
973 974 975 976 977
	/*
	 * these three are in extended format (availability of single
	 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
	 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
	 */
C
Chris Mason 已提交
978 979 980
	u64 avail_data_alloc_bits;
	u64 avail_metadata_alloc_bits;
	u64 avail_system_alloc_bits;
981

982 983 984
	/* restriper state */
	spinlock_t balance_lock;
	struct mutex balance_mutex;
985 986
	atomic_t balance_running;
	atomic_t balance_pause_req;
987
	atomic_t balance_cancel_req;
988
	struct btrfs_balance_control *balance_ctl;
989
	wait_queue_head_t balance_wait_q;
990

991 992 993
	unsigned data_chunk_allocations;
	unsigned metadata_ratio;

994
	void *bdev_holder;
L
liubo 已提交
995

A
Arne Jansen 已提交
996 997 998 999 1000 1001 1002 1003
	/* private scrub information */
	struct mutex scrub_lock;
	atomic_t scrubs_running;
	atomic_t scrub_pause_req;
	atomic_t scrubs_paused;
	atomic_t scrub_cancel_req;
	wait_queue_head_t scrub_pause_wait;
	int scrub_workers_refcnt;
1004 1005 1006
	struct btrfs_workqueue *scrub_workers;
	struct btrfs_workqueue *scrub_wr_completion_workers;
	struct btrfs_workqueue *scrub_nocow_workers;
1007
	struct btrfs_workqueue *scrub_parity_workers;
A
Arne Jansen 已提交
1008

1009 1010 1011
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	u32 check_integrity_print_mask;
#endif
1012 1013 1014 1015 1016
	/* is qgroup tracking in a consistent state? */
	u64 qgroup_flags;

	/* holds configuration and tracking. Protected by qgroup_lock */
	struct rb_root qgroup_tree;
J
Josef Bacik 已提交
1017
	struct rb_root qgroup_op_tree;
1018
	spinlock_t qgroup_lock;
J
Josef Bacik 已提交
1019 1020
	spinlock_t qgroup_op_lock;
	atomic_t qgroup_op_seq;
1021

1022 1023 1024 1025 1026 1027
	/*
	 * used to avoid frequently calling ulist_alloc()/ulist_free()
	 * when doing qgroup accounting, it must be protected by qgroup_lock.
	 */
	struct ulist *qgroup_ulist;

1028 1029 1030
	/* protect user change for quota operations */
	struct mutex qgroup_ioctl_lock;

1031 1032 1033
	/* list of dirty qgroups to be written at next commit */
	struct list_head dirty_qgroups;

1034
	/* used by qgroup for an efficient tree traversal */
1035
	u64 qgroup_seq;
1036

J
Jan Schmidt 已提交
1037 1038 1039
	/* qgroup rescan items */
	struct mutex qgroup_rescan_lock; /* protects the progress item */
	struct btrfs_key qgroup_rescan_progress;
1040
	struct btrfs_workqueue *qgroup_rescan_workers;
1041
	struct completion qgroup_rescan_completion;
1042
	struct btrfs_work qgroup_rescan_work;
1043
	bool qgroup_rescan_running;	/* protected by qgroup_rescan_lock */
J
Jan Schmidt 已提交
1044

L
liubo 已提交
1045
	/* filesystem state */
1046
	unsigned long fs_state;
1047 1048

	struct btrfs_delayed_root *delayed_root;
C
Chris Mason 已提交
1049

1050 1051 1052
	/* readahead tree */
	spinlock_t reada_lock;
	struct radix_tree_root reada_tree;
1053

Z
Zhao Lei 已提交
1054 1055 1056
	/* readahead works cnt */
	atomic_t reada_works_cnt;

1057 1058 1059 1060
	/* Extent buffer radix tree */
	spinlock_t buffer_lock;
	struct radix_tree_root buffer_radix;

C
Chris Mason 已提交
1061 1062
	/* next backup root to be overwritten */
	int backup_root_index;
1063 1064

	int num_tolerated_disk_barrier_failures;
1065 1066 1067

	/* device replace state */
	struct btrfs_dev_replace dev_replace;
1068 1069

	atomic_t mutually_exclusive_operation_running;
S
Stefan Behrens 已提交
1070

1071 1072 1073
	struct percpu_counter bio_counter;
	wait_queue_head_t replace_wait;

S
Stefan Behrens 已提交
1074
	struct semaphore uuid_tree_rescan_sem;
1075 1076 1077

	/* Used to reclaim the metadata space in the background. */
	struct work_struct async_reclaim_work;
1078 1079 1080

	spinlock_t unused_bgs_lock;
	struct list_head unused_bgs;
1081
	struct mutex unused_bg_unpin_mutex;
1082
	struct mutex delete_unused_bgs_mutex;
1083 1084 1085

	/* For btrfs to record security options */
	struct security_mnt_opts security_opts;
1086 1087 1088 1089 1090 1091

	/*
	 * Chunks that can't be freed yet (under a trim/discard operation)
	 * and will be latter freed. Protected by fs_info->chunk_mutex.
	 */
	struct list_head pinned_chunks;
1092

1093 1094
	/* Used to record internally whether fs has been frozen */
	int fs_frozen;
1095 1096 1097 1098 1099

	/* Cached block sizes */
	u32 nodesize;
	u32 sectorsize;
	u32 stripesize;
1100
};
1101

1102 1103 1104 1105 1106
static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
{
	return sb->s_fs_info;
}

1107 1108 1109 1110 1111
struct btrfs_subvolume_writers {
	struct percpu_counter	counter;
	wait_queue_head_t	wait;
};

1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
/*
 * The state of btrfs root
 */
/*
 * btrfs_record_root_in_trans is a multi-step process,
 * and it can race with the balancing code.   But the
 * race is very small, and only the first time the root
 * is added to each transaction.  So IN_TRANS_SETUP
 * is used to tell us when more checks are required
 */
#define BTRFS_ROOT_IN_TRANS_SETUP	0
#define BTRFS_ROOT_REF_COWS		1
#define BTRFS_ROOT_TRACK_DIRTY		2
#define BTRFS_ROOT_IN_RADIX		3
1126 1127 1128 1129 1130
#define BTRFS_ROOT_ORPHAN_ITEM_INSERTED	4
#define BTRFS_ROOT_DEFRAG_RUNNING	5
#define BTRFS_ROOT_FORCE_COW		6
#define BTRFS_ROOT_MULTI_LOG_TASKS	7
#define BTRFS_ROOT_DIRTY		8
1131

1132 1133
/*
 * in ram representation of the tree.  extent_root is used for all allocations
1134
 * and for the extent tree extent_root root.
1135 1136
 */
struct btrfs_root {
1137
	struct extent_buffer *node;
1138

1139
	struct extent_buffer *commit_root;
1140
	struct btrfs_root *log_root;
Z
Zheng Yan 已提交
1141
	struct btrfs_root *reloc_root;
Y
Yan Zheng 已提交
1142

1143
	unsigned long state;
1144 1145
	struct btrfs_root_item root_item;
	struct btrfs_key root_key;
1146
	struct btrfs_fs_info *fs_info;
1147 1148
	struct extent_io_tree dirty_log_pages;

1149
	struct mutex objectid_mutex;
Y
Yan Zheng 已提交
1150

1151 1152 1153
	spinlock_t accounting_lock;
	struct btrfs_block_rsv *block_rsv;

1154 1155
	/* free ino cache stuff */
	struct btrfs_free_space_ctl *free_ino_ctl;
1156 1157 1158
	enum btrfs_caching_type ino_cache_state;
	spinlock_t ino_cache_lock;
	wait_queue_head_t ino_cache_wait;
1159
	struct btrfs_free_space_ctl *free_ino_pinned;
1160 1161
	u64 ino_cache_progress;
	struct inode *ino_cache_inode;
1162

1163
	struct mutex log_mutex;
Y
Yan Zheng 已提交
1164 1165
	wait_queue_head_t log_writer_wait;
	wait_queue_head_t log_commit_wait[2];
1166
	struct list_head log_ctxs[2];
Y
Yan Zheng 已提交
1167 1168
	atomic_t log_writers;
	atomic_t log_commit[2];
M
Miao Xie 已提交
1169
	atomic_t log_batch;
1170
	int log_transid;
1171 1172 1173
	/* No matter the commit succeeds or not*/
	int log_transid_committed;
	/* Just be updated when the commit succeeds. */
1174
	int last_log_commit;
1175
	pid_t log_start_pid;
1176

1177 1178
	u64 objectid;
	u64 last_trans;
1179

1180
	u32 type;
1181 1182

	u64 highest_objectid;
C
Chris Mason 已提交
1183

1184
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1185
	/* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */
1186
	u64 alloc_bytenr;
1187
#endif
1188

1189
	u64 defrag_trans_start;
1190
	struct btrfs_key defrag_progress;
C
Chris Mason 已提交
1191
	struct btrfs_key defrag_max;
1192
	char *name;
1193 1194 1195

	/* the dirty list is only used by non-reference counted roots */
	struct list_head dirty_list;
1196

1197 1198
	struct list_head root_list;

1199 1200 1201
	spinlock_t log_extents_lock[2];
	struct list_head logged_list[2];

1202
	spinlock_t orphan_lock;
1203
	atomic_t orphan_inodes;
1204 1205
	struct btrfs_block_rsv *orphan_block_rsv;
	int orphan_cleanup_state;
1206

1207 1208 1209 1210
	spinlock_t inode_lock;
	/* red-black tree that keeps track of in-memory inodes */
	struct rb_root inode_tree;

1211 1212 1213 1214 1215
	/*
	 * radix tree that keeps track of delayed nodes of every inode,
	 * protected by inode_lock
	 */
	struct radix_tree_root delayed_nodes_tree;
1216 1217 1218 1219
	/*
	 * right now this just gets used so that a root has its own devid
	 * for stat.  It may be used for more later
	 */
1220
	dev_t anon_dev;
1221

1222
	spinlock_t root_item_lock;
1223
	atomic_t refs;
1224

1225
	struct mutex delalloc_mutex;
1226 1227 1228 1229 1230 1231 1232 1233 1234
	spinlock_t delalloc_lock;
	/*
	 * all of the inodes that have delalloc bytes.  It is possible for
	 * this list to be empty even when there is still dirty data=ordered
	 * extents waiting to finish IO.
	 */
	struct list_head delalloc_inodes;
	struct list_head delalloc_root;
	u64 nr_delalloc_inodes;
1235 1236

	struct mutex ordered_extent_mutex;
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	/*
	 * this is used by the balancing code to wait for all the pending
	 * ordered extents
	 */
	spinlock_t ordered_extent_lock;

	/*
	 * all of the data=ordered extents pending writeback
	 * these can span multiple transactions and basically include
	 * every dirty data page that isn't from nodatacow
	 */
	struct list_head ordered_extents;
	struct list_head ordered_root;
	u64 nr_ordered_extents;
1251 1252 1253 1254 1255 1256

	/*
	 * Number of currently running SEND ioctls to prevent
	 * manipulation with the read-only status via SUBVOL_SETFLAGS
	 */
	int send_in_progress;
1257 1258
	struct btrfs_subvolume_writers *subv_writers;
	atomic_t will_be_snapshoted;
1259 1260 1261

	/* For qgroup metadata space reserve */
	atomic_t qgroup_meta_rsv;
1262
};
1263 1264 1265 1266
static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
{
	return btrfs_sb(inode->i_sb)->sectorsize;
}
1267

1268 1269 1270 1271 1272
static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 blocksize)
{
	return blocksize - sizeof(struct btrfs_header);
}

1273
static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1274
{
1275
	return __BTRFS_LEAF_DATA_SIZE(info->nodesize);
1276 1277
}

1278
static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
1279
{
1280
	return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
1281 1282
}

1283
static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
1284
{
1285
	return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
1286 1287 1288 1289
}

#define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
		(offsetof(struct btrfs_file_extent_item, disk_bytenr))
1290
static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
1291
{
1292
	return BTRFS_MAX_ITEM_SIZE(info) -
1293 1294 1295
	       BTRFS_FILE_EXTENT_INLINE_DATA_START;
}

1296
static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
1297
{
1298
	return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
1299 1300
}

1301 1302 1303 1304 1305
/*
 * Flags for mount options.
 *
 * Note: don't forget to add new options to btrfs_show_options()
 */
1306 1307 1308
#define BTRFS_MOUNT_NODATASUM		(1 << 0)
#define BTRFS_MOUNT_NODATACOW		(1 << 1)
#define BTRFS_MOUNT_NOBARRIER		(1 << 2)
1309
#define BTRFS_MOUNT_SSD			(1 << 3)
1310
#define BTRFS_MOUNT_DEGRADED		(1 << 4)
C
Chris Mason 已提交
1311
#define BTRFS_MOUNT_COMPRESS		(1 << 5)
S
Sage Weil 已提交
1312
#define BTRFS_MOUNT_NOTREELOG           (1 << 6)
1313
#define BTRFS_MOUNT_FLUSHONCOMMIT       (1 << 7)
1314
#define BTRFS_MOUNT_SSD_SPREAD		(1 << 8)
C
Chris Mason 已提交
1315
#define BTRFS_MOUNT_NOSSD		(1 << 9)
C
Christoph Hellwig 已提交
1316
#define BTRFS_MOUNT_DISCARD		(1 << 10)
C
Chris Mason 已提交
1317
#define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)
1318
#define BTRFS_MOUNT_SPACE_CACHE		(1 << 12)
1319
#define BTRFS_MOUNT_CLEAR_CACHE		(1 << 13)
1320
#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
1321
#define BTRFS_MOUNT_ENOSPC_DEBUG	 (1 << 15)
C
Chris Mason 已提交
1322
#define BTRFS_MOUNT_AUTO_DEFRAG		(1 << 16)
C
Chris Mason 已提交
1323
#define BTRFS_MOUNT_INODE_MAP_CACHE	(1 << 17)
1324
#define BTRFS_MOUNT_USEBACKUPROOT	(1 << 18)
1325
#define BTRFS_MOUNT_SKIP_BALANCE	(1 << 19)
1326 1327
#define BTRFS_MOUNT_CHECK_INTEGRITY	(1 << 20)
#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
J
Jeff Mahoney 已提交
1328
#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR	(1 << 22)
1329
#define BTRFS_MOUNT_RESCAN_UUID_TREE	(1 << 23)
1330 1331
#define BTRFS_MOUNT_FRAGMENT_DATA	(1 << 24)
#define BTRFS_MOUNT_FRAGMENT_METADATA	(1 << 25)
1332
#define BTRFS_MOUNT_FREE_SPACE_TREE	(1 << 26)
1333
#define BTRFS_MOUNT_NOLOGREPLAY		(1 << 27)
1334

1335
#define BTRFS_DEFAULT_COMMIT_INTERVAL	(30)
1336
#define BTRFS_DEFAULT_MAX_INLINE	(2048)
1337

1338 1339
#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)
#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)
M
Miao Xie 已提交
1340
#define btrfs_raw_test_opt(o, opt)	((o) & BTRFS_MOUNT_##opt)
1341
#define btrfs_test_opt(fs_info, opt)	((fs_info)->mount_opt & \
1342
					 BTRFS_MOUNT_##opt)
1343

1344
#define btrfs_set_and_info(fs_info, opt, fmt, args...)			\
1345
{									\
1346 1347 1348
	if (!btrfs_test_opt(fs_info, opt))				\
		btrfs_info(fs_info, fmt, ##args);			\
	btrfs_set_opt(fs_info->mount_opt, opt);				\
1349 1350
}

1351
#define btrfs_clear_and_info(fs_info, opt, fmt, args...)		\
1352
{									\
1353 1354 1355
	if (btrfs_test_opt(fs_info, opt))				\
		btrfs_info(fs_info, fmt, ##args);			\
	btrfs_clear_opt(fs_info->mount_opt, opt);			\
1356 1357
}

1358 1359
#ifdef CONFIG_BTRFS_DEBUG
static inline int
1360
btrfs_should_fragment_free_space(struct btrfs_block_group_cache *block_group)
1361
{
1362
	struct btrfs_fs_info *fs_info = block_group->fs_info;
1363 1364

	return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&
1365
		block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
1366
	       (btrfs_test_opt(fs_info, FRAGMENT_DATA) &&
1367 1368 1369 1370
		block_group->flags &  BTRFS_BLOCK_GROUP_DATA);
}
#endif

1371 1372 1373 1374 1375 1376 1377 1378
/*
 * Requests for changes that need to be done during transaction commit.
 *
 * Internal mount options that are used for special handling of the real
 * mount options (eg. cannot be set during remount and have to be set during
 * transaction commit)
 */

1379 1380
#define BTRFS_PENDING_SET_INODE_MAP_CACHE	(0)
#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE	(1)
1381
#define BTRFS_PENDING_COMMIT			(2)
1382

1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
#define btrfs_test_pending(info, opt)	\
	test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
#define btrfs_set_pending(info, opt)	\
	set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
#define btrfs_clear_pending(info, opt)	\
	clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)

/*
 * Helpers for setting pending mount option changes.
 *
 * Expects corresponding macros
 * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name
 */
#define btrfs_set_pending_and_info(info, opt, fmt, args...)            \
do {                                                                   \
       if (!btrfs_raw_test_opt((info)->mount_opt, opt)) {              \
               btrfs_info((info), fmt, ##args);                        \
               btrfs_set_pending((info), SET_##opt);                   \
               btrfs_clear_pending((info), CLEAR_##opt);               \
       }                                                               \
} while(0)

#define btrfs_clear_pending_and_info(info, opt, fmt, args...)          \
do {                                                                   \
       if (btrfs_raw_test_opt((info)->mount_opt, opt)) {               \
               btrfs_info((info), fmt, ##args);                        \
               btrfs_set_pending((info), CLEAR_##opt);                 \
               btrfs_clear_pending((info), SET_##opt);                 \
       }                                                               \
} while(0)

Y
Yan 已提交
1414 1415 1416
/*
 * Inode flags
 */
Y
Yan 已提交
1417 1418 1419
#define BTRFS_INODE_NODATASUM		(1 << 0)
#define BTRFS_INODE_NODATACOW		(1 << 1)
#define BTRFS_INODE_READONLY		(1 << 2)
C
Chris Mason 已提交
1420
#define BTRFS_INODE_NOCOMPRESS		(1 << 3)
Y
Yan Zheng 已提交
1421
#define BTRFS_INODE_PREALLOC		(1 << 4)
1422 1423 1424 1425 1426 1427
#define BTRFS_INODE_SYNC		(1 << 5)
#define BTRFS_INODE_IMMUTABLE		(1 << 6)
#define BTRFS_INODE_APPEND		(1 << 7)
#define BTRFS_INODE_NODUMP		(1 << 8)
#define BTRFS_INODE_NOATIME		(1 << 9)
#define BTRFS_INODE_DIRSYNC		(1 << 10)
1428
#define BTRFS_INODE_COMPRESS		(1 << 11)
1429

1430 1431
#define BTRFS_INODE_ROOT_ITEM_INIT	(1 << 31)

1432 1433 1434 1435 1436 1437
struct btrfs_map_token {
	struct extent_buffer *eb;
	char *kaddr;
	unsigned long offset;
};

1438 1439 1440
#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
				((bytes) >> (fs_info)->sb->s_blocksize_bits)

1441 1442
static inline void btrfs_init_map_token (struct btrfs_map_token *token)
{
J
Josef Bacik 已提交
1443
	token->kaddr = NULL;
1444 1445
}

1446
/* some macros to generate set/get functions for the struct fields.  This
1447 1448 1449 1450 1451 1452 1453
 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
 * one for u8:
 */
#define le8_to_cpu(v) (v)
#define cpu_to_le8(v) (v)
#define __le8 u8

1454
#define read_eb_member(eb, ptr, type, member, result) (\
1455 1456 1457 1458 1459
	read_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

1460
#define write_eb_member(eb, ptr, type, member, result) (\
1461 1462 1463 1464 1465
	write_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

L
Li Zefan 已提交
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
#define DECLARE_BTRFS_SETGET_BITS(bits)					\
u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr,	\
			       unsigned long off,			\
                              struct btrfs_map_token *token);		\
void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr,	\
			    unsigned long off, u##bits val,		\
			    struct btrfs_map_token *token);		\
static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \
				       unsigned long off)		\
{									\
	return btrfs_get_token_##bits(eb, ptr, off, NULL);		\
}									\
static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \
				    unsigned long off, u##bits val)	\
{									\
       btrfs_set_token_##bits(eb, ptr, off, val, NULL);			\
}

DECLARE_BTRFS_SETGET_BITS(8)
DECLARE_BTRFS_SETGET_BITS(16)
DECLARE_BTRFS_SETGET_BITS(32)
DECLARE_BTRFS_SETGET_BITS(64)

1489
#define BTRFS_SETGET_FUNCS(name, type, member, bits)			\
L
Li Zefan 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s)	\
{									\
	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
	return btrfs_get_##bits(eb, s, offsetof(type, member));		\
}									\
static inline void btrfs_set_##name(struct extent_buffer *eb, type *s,	\
				    u##bits val)			\
{									\
	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
	btrfs_set_##bits(eb, s, offsetof(type, member), val);		\
}									\
static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \
					 struct btrfs_map_token *token)	\
{									\
	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
	return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
}									\
static inline void btrfs_set_token_##name(struct extent_buffer *eb,	\
					  type *s, u##bits val,		\
                                         struct btrfs_map_token *token)	\
{									\
	BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);	\
	btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
}
1514 1515 1516 1517

#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)		\
static inline u##bits btrfs_##name(struct extent_buffer *eb)		\
{									\
1518
	type *p = page_address(eb->pages[0]);				\
D
David Miller 已提交
1519
	u##bits res = le##bits##_to_cpu(p->member);			\
1520
	return res;							\
1521 1522 1523 1524
}									\
static inline void btrfs_set_##name(struct extent_buffer *eb,		\
				    u##bits val)			\
{									\
1525
	type *p = page_address(eb->pages[0]);				\
D
David Miller 已提交
1526
	p->member = cpu_to_le##bits(val);				\
1527
}
C
Chris Mason 已提交
1528

1529 1530 1531 1532 1533 1534 1535 1536
#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)		\
static inline u##bits btrfs_##name(type *s)				\
{									\
	return le##bits##_to_cpu(s->member);				\
}									\
static inline void btrfs_set_##name(type *s, u##bits val)		\
{									\
	s->member = cpu_to_le##bits(val);				\
C
Chris Mason 已提交
1537 1538
}

1539 1540 1541 1542 1543
BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1544 1545
BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
		   start_offset, 64);
1546 1547
BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1548 1549 1550
BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
Y
Yan Zheng 已提交
1551
BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1552

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
			 total_bytes, 64);
BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
			 bytes_used, 64);
BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
			 io_align, 32);
BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
			 io_width, 32);
BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
			 sector_size, 32);
BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1565 1566 1567 1568 1569 1570
BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
			 dev_group, 32);
BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
			 seek_speed, 8);
BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
			 bandwidth, 8);
Y
Yan Zheng 已提交
1571 1572
BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
			 generation, 64);
1573

1574
static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
1575
{
1576
	return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
1577 1578
}

1579
static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
Y
Yan Zheng 已提交
1580
{
1581
	return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
Y
Yan Zheng 已提交
1582 1583
}

1584
BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1585 1586 1587 1588 1589 1590 1591
BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
C
Chris Mason 已提交
1592
BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1593 1594 1595
BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);

1596 1597 1598 1599 1600 1601
static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
{
	return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
}

BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
			 stripe_len, 64);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
			 io_align, 32);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
			 io_width, 32);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
			 sector_size, 32);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
			 num_stripes, 16);
C
Chris Mason 已提交
1614 1615
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
			 sub_stripes, 16);
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);

static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
						   int nr)
{
	unsigned long offset = (unsigned long)c;
	offset += offsetof(struct btrfs_chunk, stripe);
	offset += nr * sizeof(struct btrfs_stripe);
	return (struct btrfs_stripe *)offset;
}

1628 1629 1630 1631 1632
static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
{
	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
}

1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
					 struct btrfs_chunk *c, int nr)
{
	return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
}

static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
					 struct btrfs_chunk *c, int nr)
{
	return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
}

1645 1646 1647 1648 1649
/* struct btrfs_block_group_item */
BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
			 used, 64);
BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
			 used, 64);
1650 1651
BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
			struct btrfs_block_group_item, chunk_objectid, 64);
1652 1653

BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
1654 1655 1656 1657 1658
		   struct btrfs_block_group_item, chunk_objectid, 64);
BTRFS_SETGET_FUNCS(disk_block_group_flags,
		   struct btrfs_block_group_item, flags, 64);
BTRFS_SETGET_STACK_FUNCS(block_group_flags,
			struct btrfs_block_group_item, flags, 64);
C
Chris Mason 已提交
1659

1660 1661 1662 1663 1664
/* struct btrfs_free_space_info */
BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
		   extent_count, 32);
BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);

1665 1666
/* struct btrfs_inode_ref */
BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1667
BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1668

M
Mark Fasheh 已提交
1669 1670 1671 1672 1673 1674 1675
/* struct btrfs_inode_extref */
BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
		   parent_objectid, 64);
BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
		   name_len, 16);
BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);

1676 1677
/* struct btrfs_inode_item */
BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1678
BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1679
BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1680
BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1681
BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1682 1683 1684 1685 1686
BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1687
BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1688
BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
			 generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
			 sequence, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
			 transid, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
			 nbytes, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
			 block_group, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
1706 1707
BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1708 1709
BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
C
Chris Mason 已提交
1710

1711
/* struct btrfs_dev_extent */
1712 1713 1714 1715 1716 1717
BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
		   chunk_tree, 64);
BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
		   chunk_objectid, 64);
BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
		   chunk_offset, 64);
1718 1719
BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);

1720
static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1721 1722
{
	unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1723
	return (unsigned long)dev + ptr;
1724 1725
}

1726 1727 1728 1729
BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
		   generation, 64);
BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1730

1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);


BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);

static inline void btrfs_tree_block_key(struct extent_buffer *eb,
					struct btrfs_tree_block_info *item,
					struct btrfs_disk_key *key)
{
	read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
}

static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
					    struct btrfs_tree_block_info *item,
					    struct btrfs_disk_key *key)
{
	write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
}
C
Chris Mason 已提交
1749

1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
		   root, 64);
BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
		   objectid, 64);
BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
		   offset, 64);
BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
		   count, 32);

BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
		   count, 32);

BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
		   type, 8);
BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
		   offset, 64);

static inline u32 btrfs_extent_inline_ref_size(int type)
{
	if (type == BTRFS_TREE_BLOCK_REF_KEY ||
	    type == BTRFS_SHARED_BLOCK_REF_KEY)
		return sizeof(struct btrfs_extent_inline_ref);
	if (type == BTRFS_SHARED_DATA_REF_KEY)
		return sizeof(struct btrfs_shared_data_ref) +
		       sizeof(struct btrfs_extent_inline_ref);
	if (type == BTRFS_EXTENT_DATA_REF_KEY)
		return sizeof(struct btrfs_extent_data_ref) +
		       offsetof(struct btrfs_extent_inline_ref, offset);
	BUG();
	return 0;
}

BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
		   generation, 64);
BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
C
Chris Mason 已提交
1787

1788 1789
/* struct btrfs_node */
BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1790
BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1791 1792 1793 1794
BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
			 blockptr, 64);
BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
			 generation, 64);
C
Chris Mason 已提交
1795

1796
static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1797
{
1798 1799 1800 1801
	unsigned long ptr;
	ptr = offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
	return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
C
Chris Mason 已提交
1802 1803
}

1804 1805
static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
					   int nr, u64 val)
C
Chris Mason 已提交
1806
{
1807 1808 1809 1810
	unsigned long ptr;
	ptr = offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
	btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
C
Chris Mason 已提交
1811 1812
}

1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
{
	unsigned long ptr;
	ptr = offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
	return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
}

static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
						 int nr, u64 val)
{
	unsigned long ptr;
	ptr = offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
	btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
}

1830
static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1831
{
1832 1833
	return offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
1834 1835
}

1836 1837 1838
void btrfs_node_key(struct extent_buffer *eb,
		    struct btrfs_disk_key *disk_key, int nr);

1839 1840
static inline void btrfs_set_node_key(struct extent_buffer *eb,
				      struct btrfs_disk_key *disk_key, int nr)
1841
{
1842 1843 1844 1845
	unsigned long ptr;
	ptr = btrfs_node_key_ptr_offset(nr);
	write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
		       struct btrfs_key_ptr, key, disk_key);
1846 1847
}

1848 1849 1850
/* struct btrfs_item */
BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1851 1852
BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
1853

1854
static inline unsigned long btrfs_item_nr_offset(int nr)
1855
{
1856 1857
	return offsetof(struct btrfs_leaf, items) +
		sizeof(struct btrfs_item) * nr;
1858 1859
}

1860
static inline struct btrfs_item *btrfs_item_nr(int nr)
C
Chris Mason 已提交
1861
{
1862
	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
C
Chris Mason 已提交
1863 1864
}

1865 1866
static inline u32 btrfs_item_end(struct extent_buffer *eb,
				 struct btrfs_item *item)
C
Chris Mason 已提交
1867
{
1868
	return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
C
Chris Mason 已提交
1869 1870
}

1871
static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1872
{
1873
	return btrfs_item_end(eb, btrfs_item_nr(nr));
C
Chris Mason 已提交
1874 1875
}

1876
static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1877
{
1878
	return btrfs_item_offset(eb, btrfs_item_nr(nr));
C
Chris Mason 已提交
1879 1880
}

1881
static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1882
{
1883
	return btrfs_item_size(eb, btrfs_item_nr(nr));
C
Chris Mason 已提交
1884 1885
}

1886 1887
static inline void btrfs_item_key(struct extent_buffer *eb,
			   struct btrfs_disk_key *disk_key, int nr)
1888
{
1889
	struct btrfs_item *item = btrfs_item_nr(nr);
1890
	read_eb_member(eb, item, struct btrfs_item, key, disk_key);
1891 1892
}

1893 1894
static inline void btrfs_set_item_key(struct extent_buffer *eb,
			       struct btrfs_disk_key *disk_key, int nr)
1895
{
1896
	struct btrfs_item *item = btrfs_item_nr(nr);
1897
	write_eb_member(eb, item, struct btrfs_item, key, disk_key);
1898 1899
}

1900 1901
BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);

1902 1903 1904 1905 1906 1907 1908
/*
 * struct btrfs_root_ref
 */
BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);

1909
/* struct btrfs_dir_item */
J
Josef Bacik 已提交
1910
BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
1911 1912
BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
1913
BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
1914 1915 1916 1917 1918 1919 1920
BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
			 data_len, 16);
BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
			 name_len, 16);
BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
			 transid, 64);
1921

1922 1923 1924
static inline void btrfs_dir_item_key(struct extent_buffer *eb,
				      struct btrfs_dir_item *item,
				      struct btrfs_disk_key *key)
1925
{
1926
	read_eb_member(eb, item, struct btrfs_dir_item, location, key);
1927 1928
}

1929 1930 1931
static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
					  struct btrfs_dir_item *item,
					  struct btrfs_disk_key *key)
1932
{
1933
	write_eb_member(eb, item, struct btrfs_dir_item, location, key);
1934 1935
}

1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
		   num_entries, 64);
BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
		   num_bitmaps, 64);
BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
		   generation, 64);

static inline void btrfs_free_space_key(struct extent_buffer *eb,
					struct btrfs_free_space_header *h,
					struct btrfs_disk_key *key)
{
	read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
}

static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
					    struct btrfs_free_space_header *h,
					    struct btrfs_disk_key *key)
{
	write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
}

1957 1958 1959 1960 1961
/* struct btrfs_disk_key */
BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
			 objectid, 64);
BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
1962

C
Chris Mason 已提交
1963
static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
1964
					 const struct btrfs_disk_key *disk)
C
Chris Mason 已提交
1965 1966
{
	cpu->offset = le64_to_cpu(disk->offset);
1967
	cpu->type = disk->type;
C
Chris Mason 已提交
1968 1969 1970 1971
	cpu->objectid = le64_to_cpu(disk->objectid);
}

static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
1972
					 const struct btrfs_key *cpu)
C
Chris Mason 已提交
1973 1974
{
	disk->offset = cpu_to_le64(cpu->offset);
1975
	disk->type = cpu->type;
C
Chris Mason 已提交
1976 1977 1978
	disk->objectid = cpu_to_le64(cpu->objectid);
}

1979 1980
static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
				  struct btrfs_key *key, int nr)
1981
{
1982 1983 1984
	struct btrfs_disk_key disk_key;
	btrfs_node_key(eb, &disk_key, nr);
	btrfs_disk_key_to_cpu(key, &disk_key);
1985 1986
}

1987 1988
static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
				  struct btrfs_key *key, int nr)
1989
{
1990 1991 1992
	struct btrfs_disk_key disk_key;
	btrfs_item_key(eb, &disk_key, nr);
	btrfs_disk_key_to_cpu(key, &disk_key);
1993 1994
}

1995 1996 1997
static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
				      struct btrfs_dir_item *item,
				      struct btrfs_key *key)
1998
{
1999 2000 2001
	struct btrfs_disk_key disk_key;
	btrfs_dir_item_key(eb, item, &disk_key);
	btrfs_disk_key_to_cpu(key, &disk_key);
2002 2003
}

2004
static inline u8 btrfs_key_type(const struct btrfs_key *key)
2005
{
2006
	return key->type;
2007 2008
}

2009
static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2010
{
2011
	key->type = val;
2012 2013
}

2014
/* struct btrfs_header */
2015
BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2016 2017 2018 2019
BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
			  generation, 64);
BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
2020
BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2021
BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2022 2023 2024 2025 2026 2027
BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
			 generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
			 nritems, 32);
BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
2028

2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
{
	return (btrfs_header_flags(eb) & flag) == flag;
}

static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
{
	u64 flags = btrfs_header_flags(eb);
	btrfs_set_header_flags(eb, flags | flag);
	return (flags & flag) == flag;
}

static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
{
	u64 flags = btrfs_header_flags(eb);
	btrfs_set_header_flags(eb, flags & ~flag);
	return (flags & flag) == flag;
}

2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062
static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
{
	u64 flags = btrfs_header_flags(eb);
	return flags >> BTRFS_BACKREF_REV_SHIFT;
}

static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
						int rev)
{
	u64 flags = btrfs_header_flags(eb);
	flags &= ~BTRFS_BACKREF_REV_MASK;
	flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
	btrfs_set_header_flags(eb, flags);
}

2063
static inline unsigned long btrfs_header_fsid(void)
2064
{
2065
	return offsetof(struct btrfs_header, fsid);
2066 2067
}

2068
static inline unsigned long btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
2069
{
2070
	return offsetof(struct btrfs_header, chunk_tree_uuid);
2071 2072
}

2073
static inline int btrfs_is_leaf(struct extent_buffer *eb)
2074
{
C
Chris Mason 已提交
2075
	return btrfs_header_level(eb) == 0;
2076 2077
}

2078
/* struct btrfs_root_item */
2079 2080
BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
		   generation, 64);
2081
BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2082 2083
BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2084

2085 2086
BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
			 generation, 64);
2087 2088
BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2089 2090
BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2091
BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2092 2093
BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
Y
Yan Zheng 已提交
2094 2095
BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
			 last_snapshot, 64);
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105
BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
			 generation_v2, 64);
BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
			 ctransid, 64);
BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
			 otransid, 64);
BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
			 stransid, 64);
BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
			 rtransid, 64);
C
Chris Mason 已提交
2106

L
Li Zefan 已提交
2107 2108
static inline bool btrfs_root_readonly(struct btrfs_root *root)
{
2109
	return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
L
Li Zefan 已提交
2110 2111
}

2112 2113 2114 2115 2116
static inline bool btrfs_root_dead(struct btrfs_root *root)
{
	return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
}

C
Chris Mason 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
/* struct btrfs_root_backup */
BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
		   tree_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
		   tree_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
		   tree_root_level, 8);

BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
		   chunk_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
		   chunk_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
		   chunk_root_level, 8);

BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
		   extent_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
		   extent_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
		   extent_root_level, 8);

BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
		   fs_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
		   fs_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
		   fs_root_level, 8);

BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
		   dev_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
		   dev_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
		   dev_root_level, 8);

BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
		   csum_root, 64);
BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
		   csum_root_gen, 64);
BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
		   csum_root_level, 8);
BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
		   total_bytes, 64);
BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
		   bytes_used, 64);
BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
		   num_devices, 64);

2166 2167
/* struct btrfs_balance_item */
BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2168

2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
static inline void btrfs_balance_data(struct extent_buffer *eb,
				      struct btrfs_balance_item *bi,
				      struct btrfs_disk_balance_args *ba)
{
	read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
}

static inline void btrfs_set_balance_data(struct extent_buffer *eb,
					  struct btrfs_balance_item *bi,
					  struct btrfs_disk_balance_args *ba)
{
	write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
}

static inline void btrfs_balance_meta(struct extent_buffer *eb,
				      struct btrfs_balance_item *bi,
				      struct btrfs_disk_balance_args *ba)
{
	read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
}

static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
					  struct btrfs_balance_item *bi,
					  struct btrfs_disk_balance_args *ba)
{
	write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
}

static inline void btrfs_balance_sys(struct extent_buffer *eb,
				     struct btrfs_balance_item *bi,
				     struct btrfs_disk_balance_args *ba)
{
	read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
}

static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
					 struct btrfs_balance_item *bi,
					 struct btrfs_disk_balance_args *ba)
{
	write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
}

static inline void
btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
			       struct btrfs_disk_balance_args *disk)
{
	memset(cpu, 0, sizeof(*cpu));

	cpu->profiles = le64_to_cpu(disk->profiles);
	cpu->usage = le64_to_cpu(disk->usage);
	cpu->devid = le64_to_cpu(disk->devid);
	cpu->pstart = le64_to_cpu(disk->pstart);
	cpu->pend = le64_to_cpu(disk->pend);
	cpu->vstart = le64_to_cpu(disk->vstart);
	cpu->vend = le64_to_cpu(disk->vend);
	cpu->target = le64_to_cpu(disk->target);
	cpu->flags = le64_to_cpu(disk->flags);
2226
	cpu->limit = le64_to_cpu(disk->limit);
2227 2228
	cpu->stripes_min = le32_to_cpu(disk->stripes_min);
	cpu->stripes_max = le32_to_cpu(disk->stripes_max);
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
}

static inline void
btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
			       struct btrfs_balance_args *cpu)
{
	memset(disk, 0, sizeof(*disk));

	disk->profiles = cpu_to_le64(cpu->profiles);
	disk->usage = cpu_to_le64(cpu->usage);
	disk->devid = cpu_to_le64(cpu->devid);
	disk->pstart = cpu_to_le64(cpu->pstart);
	disk->pend = cpu_to_le64(cpu->pend);
	disk->vstart = cpu_to_le64(cpu->vstart);
	disk->vend = cpu_to_le64(cpu->vend);
	disk->target = cpu_to_le64(cpu->target);
	disk->flags = cpu_to_le64(cpu->flags);
2246
	disk->limit = cpu_to_le64(cpu->limit);
2247 2248
	disk->stripes_min = cpu_to_le32(cpu->stripes_min);
	disk->stripes_max = cpu_to_le32(cpu->stripes_max);
2249 2250 2251
}

/* struct btrfs_super_block */
2252
BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2253
BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2254 2255 2256
BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
			 generation, 64);
BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2257 2258
BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
			 struct btrfs_super_block, sys_chunk_array_size, 32);
2259 2260
BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
			 struct btrfs_super_block, chunk_root_generation, 64);
2261 2262
BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
			 root_level, 8);
2263 2264 2265
BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
			 chunk_root, 64);
BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2266 2267 2268
			 chunk_root_level, 8);
BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
			 log_root, 64);
2269 2270
BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
			 log_root_transid, 64);
2271 2272
BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
			 log_root_level, 8);
2273 2274 2275 2276
BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
			 total_bytes, 64);
BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
			 bytes_used, 64);
2277 2278 2279 2280
BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
			 sectorsize, 32);
BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
			 nodesize, 32);
2281 2282
BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
			 stripesize, 32);
2283 2284
BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
			 root_dir_objectid, 64);
2285 2286
BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
			 num_devices, 64);
2287 2288 2289
BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
			 compat_flags, 64);
BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2290
			 compat_ro_flags, 64);
2291 2292
BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
			 incompat_flags, 64);
2293 2294
BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
			 csum_type, 16);
2295 2296
BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
			 cache_generation, 64);
2297
BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
2298 2299
BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
			 uuid_tree_generation, 64);
2300 2301 2302

static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
{
D
David Sterba 已提交
2303 2304 2305 2306
	u16 t = btrfs_super_csum_type(s);
	/*
	 * csum type is validated at mount time
	 */
2307 2308
	return btrfs_csum_sizes[t];
}
2309

2310
static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
2311
{
2312
	return offsetof(struct btrfs_leaf, items);
2313 2314
}

2315 2316 2317 2318 2319
/*
 * The leaf data grows from end-to-front in the node.
 * this returns the address of the start of the last item,
 * which is the stop of the leaf data stack
 */
2320
static inline unsigned int leaf_data_end(struct btrfs_fs_info *fs_info,
2321 2322 2323 2324 2325
					 struct extent_buffer *leaf)
{
	u32 nr = btrfs_header_nritems(leaf);

	if (nr == 0)
2326
		return BTRFS_LEAF_DATA_SIZE(fs_info);
2327 2328 2329
	return btrfs_item_offset_nr(leaf, nr - 1);
}

2330 2331
/* struct btrfs_file_extent_item */
BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2332 2333 2334 2335 2336 2337 2338 2339
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
			 struct btrfs_file_extent_item, disk_bytenr, 64);
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
			 struct btrfs_file_extent_item, offset, 64);
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
			 struct btrfs_file_extent_item, generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
			 struct btrfs_file_extent_item, num_bytes, 64);
2340 2341 2342 2343
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
			 struct btrfs_file_extent_item, disk_num_bytes, 64);
BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
			 struct btrfs_file_extent_item, compression, 8);
2344

C
Chris Mason 已提交
2345 2346
static inline unsigned long
btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
2347
{
2348
	return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
2349 2350 2351 2352
}

static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
{
2353
	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2354 2355
}

2356 2357
BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
		   disk_bytenr, 64);
2358 2359
BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
		   generation, 64);
2360 2361
BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
		   disk_num_bytes, 64);
2362 2363
BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
		  offset, 64);
2364 2365
BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
		   num_bytes, 64);
C
Chris Mason 已提交
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
		   ram_bytes, 64);
BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
		   compression, 8);
BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
		   encryption, 8);
BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
		   other_encoding, 16);

/*
 * this returns the number of bytes used by the item on disk, minus the
 * size of any extent headers.  If a file is compressed on disk, this is
 * the compressed size
 */
static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
						    struct btrfs_item *e)
{
2383
	return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
C
Chris Mason 已提交
2384
}
2385

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
/* this returns the number of file bytes represented by the inline item.
 * If an item is compressed, this is the uncompressed size
 */
static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
					       int slot,
					       struct btrfs_file_extent_item *fi)
{
	struct btrfs_map_token token;

	btrfs_init_map_token(&token);
	/*
	 * return the space used on disk if this item isn't
	 * compressed or encoded
	 */
	if (btrfs_token_file_extent_compression(eb, fi, &token) == 0 &&
	    btrfs_token_file_extent_encryption(eb, fi, &token) == 0 &&
	    btrfs_token_file_extent_other_encoding(eb, fi, &token) == 0) {
		return btrfs_file_extent_inline_item_len(eb,
							 btrfs_item_nr(slot));
	}

	/* otherwise use the ram bytes field */
	return btrfs_token_file_extent_ram_bytes(eb, fi, &token);
}


2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
/* btrfs_dev_stats_item */
static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb,
					struct btrfs_dev_stats_item *ptr,
					int index)
{
	u64 val;

	read_extent_buffer(eb, &val,
			   offsetof(struct btrfs_dev_stats_item, values) +
			    ((unsigned long)ptr) + (index * sizeof(u64)),
			   sizeof(val));
	return val;
}

static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
					     struct btrfs_dev_stats_item *ptr,
					     int index, u64 val)
{
	write_extent_buffer(eb, &val,
			    offsetof(struct btrfs_dev_stats_item, values) +
			     ((unsigned long)ptr) + (index * sizeof(u64)),
			    sizeof(val));
}

A
Arne Jansen 已提交
2436 2437 2438 2439 2440 2441 2442
/* btrfs_qgroup_status_item */
BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
		   generation, 64);
BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
		   version, 64);
BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
		   flags, 64);
J
Jan Schmidt 已提交
2443 2444
BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
		   rescan, 64);
A
Arne Jansen 已提交
2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478

/* btrfs_qgroup_info_item */
BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
		   generation, 64);
BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
		   rfer_cmpr, 64);
BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
		   excl_cmpr, 64);

BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
			 struct btrfs_qgroup_info_item, generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
			 rfer, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
			 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
			 excl, 64);
BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
			 struct btrfs_qgroup_info_item, excl_cmpr, 64);

/* btrfs_qgroup_limit_item */
BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
		   flags, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
		   max_rfer, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
		   max_excl, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
		   rsv_rfer, 64);
BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
		   rsv_excl, 64);

2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
/* btrfs_dev_replace_item */
BTRFS_SETGET_FUNCS(dev_replace_src_devid,
		   struct btrfs_dev_replace_item, src_devid, 64);
BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
		   struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
		   64);
BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
		   replace_state, 64);
BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
		   time_started, 64);
BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
		   time_stopped, 64);
BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
		   num_write_errors, 64);
BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
		   struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
		   64);
BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
		   cursor_left, 64);
BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
		   cursor_right, 64);

BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
			 struct btrfs_dev_replace_item, src_devid, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
			 struct btrfs_dev_replace_item,
			 cont_reading_from_srcdev_mode, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
			 struct btrfs_dev_replace_item, replace_state, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
			 struct btrfs_dev_replace_item, time_started, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
			 struct btrfs_dev_replace_item, time_stopped, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
			 struct btrfs_dev_replace_item, num_write_errors, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
			 struct btrfs_dev_replace_item,
			 num_uncorrectable_read_errors, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
			 struct btrfs_dev_replace_item, cursor_left, 64);
BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
			 struct btrfs_dev_replace_item, cursor_right, 64);

2522 2523
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
C
Chris Mason 已提交
2524
	((type *)(btrfs_leaf_data(leaf) + \
2525 2526 2527 2528 2529
	btrfs_item_offset_nr(leaf, slot)))

#define btrfs_item_ptr_offset(leaf, slot) \
	((unsigned long)(btrfs_leaf_data(leaf) + \
	btrfs_item_offset_nr(leaf, slot)))
2530

2531 2532 2533 2534 2535 2536
static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
{
	return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
		(space_info->flags & BTRFS_BLOCK_GROUP_DATA));
}

2537 2538
static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
{
2539
	return mapping_gfp_constraint(mapping, ~__GFP_FS);
2540 2541
}

C
Chris Mason 已提交
2542
/* extent-tree.c */
2543

2544
u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
2545

2546
static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
2547
						 unsigned num_items)
2548
{
2549
	return fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2550 2551 2552 2553 2554 2555
}

/*
 * Doing a truncate won't result in new nodes or leaves, just what we need for
 * COW.
 */
2556
static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
2557 2558
						 unsigned num_items)
{
2559
	return fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2560 2561
}

2562
int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
2563
				       struct btrfs_fs_info *fs_info);
2564
int btrfs_check_space_for_delayed_refs(struct btrfs_trans_handle *trans,
2565
				       struct btrfs_fs_info *fs_info);
2566 2567 2568
void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
					 const u64 start);
void btrfs_wait_block_group_reservations(struct btrfs_block_group_cache *bg);
2569 2570 2571
bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
void btrfs_wait_nocow_writers(struct btrfs_block_group_cache *bg);
2572
void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2573
int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2574 2575
			   struct btrfs_fs_info *fs_info, unsigned long count);
int btrfs_async_run_delayed_refs(struct btrfs_fs_info *fs_info,
2576
				 unsigned long count, u64 transid, int wait);
2577
int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2578
int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2579
			     struct btrfs_fs_info *fs_info, u64 bytenr,
2580
			     u64 offset, int metadata, u64 *refs, u64 *flags);
2581
int btrfs_pin_extent(struct btrfs_fs_info *fs_info,
2582
		     u64 bytenr, u64 num, int reserved);
2583
int btrfs_pin_extent_for_log_replay(struct btrfs_fs_info *fs_info,
2584
				    u64 bytenr, u64 num_bytes);
2585
int btrfs_exclude_logged_extents(struct btrfs_fs_info *fs_info,
2586
				 struct extent_buffer *eb);
2587
int btrfs_cross_ref_exist(struct btrfs_root *root,
2588
			  u64 objectid, u64 offset, u64 bytenr);
C
Chris Mason 已提交
2589 2590 2591
struct btrfs_block_group_cache *btrfs_lookup_block_group(
						 struct btrfs_fs_info *info,
						 u64 bytenr);
2592
void btrfs_get_block_group(struct btrfs_block_group_cache *cache);
2593
void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2594
int get_block_group_index(struct btrfs_block_group_cache *cache);
2595
struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
2596 2597 2598 2599 2600
					     struct btrfs_root *root,
					     u64 parent, u64 root_objectid,
					     const struct btrfs_disk_key *key,
					     int level, u64 hint,
					     u64 empty_size);
2601 2602 2603
void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root,
			   struct extent_buffer *buf,
2604
			   u64 parent, int last_ref);
2605 2606
int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
				     u64 root_objectid, u64 owner,
2607 2608
				     u64 offset, u64 ram_bytes,
				     struct btrfs_key *ins);
2609
int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2610
				   struct btrfs_fs_info *fs_info,
2611 2612
				   u64 root_objectid, u64 owner, u64 offset,
				   struct btrfs_key *ins);
2613
int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes, u64 num_bytes,
2614
			 u64 min_alloc_size, u64 empty_size, u64 hint_byte,
2615
			 struct btrfs_key *ins, int is_data, int delalloc);
2616
int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2617
		  struct extent_buffer *buf, int full_backref);
2618
int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2619
		  struct extent_buffer *buf, int full_backref);
2620
int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2621
				struct btrfs_fs_info *fs_info,
2622
				u64 bytenr, u64 num_bytes, u64 flags,
2623
				int level, int is_data);
Z
Zheng Yan 已提交
2624
int btrfs_free_extent(struct btrfs_trans_handle *trans,
2625
		      struct btrfs_fs_info *fs_info,
A
Arne Jansen 已提交
2626
		      u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
2627
		      u64 owner, u64 offset);
2628

2629 2630 2631
int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
			       u64 start, u64 len, int delalloc);
int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info,
2632
				       u64 start, u64 len);
2633
void btrfs_prepare_extent_commit(struct btrfs_fs_info *fs_info);
C
Chris Mason 已提交
2634
int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
2635
			       struct btrfs_fs_info *fs_info);
C
Chris Mason 已提交
2636
int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2637
			 struct btrfs_fs_info *fs_info,
Z
Zheng Yan 已提交
2638
			 u64 bytenr, u64 num_bytes, u64 parent,
2639
			 u64 root_objectid, u64 owner, u64 offset);
2640

2641
int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans,
2642
				   struct btrfs_fs_info *fs_info);
C
Chris Mason 已提交
2643
int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2644
				   struct btrfs_fs_info *fs_info);
2645
int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
2646 2647
			    struct btrfs_fs_info *fs_info);
int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
C
Chris Mason 已提交
2648
int btrfs_free_block_groups(struct btrfs_fs_info *info);
2649
int btrfs_read_block_groups(struct btrfs_fs_info *info);
2650
int btrfs_can_relocate(struct btrfs_fs_info *fs_info, u64 bytenr);
2651
int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2652
			   struct btrfs_fs_info *fs_info, u64 bytes_used,
2653
			   u64 type, u64 chunk_objectid, u64 chunk_offset,
2654
			   u64 size);
2655
struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
2656 2657
				struct btrfs_fs_info *fs_info,
				const u64 chunk_offset);
Z
Zheng Yan 已提交
2658
int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2659
			     struct btrfs_fs_info *fs_info, u64 group_start,
2660
			     struct extent_map *em);
2661
void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);
2662 2663
void btrfs_get_block_group_trimming(struct btrfs_block_group_cache *cache);
void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *cache);
2664
void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
2665
				       struct btrfs_fs_info *fs_info);
2666
u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
2667
void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
M
Miao Xie 已提交
2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679

enum btrfs_reserve_flush_enum {
	/* If we are in the transaction, we can't flush anything.*/
	BTRFS_RESERVE_NO_FLUSH,
	/*
	 * Flushing delalloc may cause deadlock somewhere, in this
	 * case, use FLUSH LIMIT
	 */
	BTRFS_RESERVE_FLUSH_LIMIT,
	BTRFS_RESERVE_FLUSH_ALL,
};

2680 2681 2682 2683 2684 2685 2686 2687 2688
enum btrfs_flush_state {
	FLUSH_DELAYED_ITEMS_NR	=	1,
	FLUSH_DELAYED_ITEMS	=	2,
	FLUSH_DELALLOC		=	3,
	FLUSH_DELALLOC_WAIT	=	4,
	ALLOC_CHUNK		=	5,
	COMMIT_TRANS		=	6,
};

2689
int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);
2690
int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes);
2691
void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);
2692 2693
void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,
					    u64 len);
2694
void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
2695
				  struct btrfs_fs_info *fs_info);
2696
void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
2697
int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
2698
				  struct btrfs_inode *inode);
2699
void btrfs_orphan_release_metadata(struct btrfs_inode *inode);
2700 2701 2702
int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
				     struct btrfs_block_rsv *rsv,
				     int nitems,
2703
				     u64 *qgroup_reserved, bool use_global_rsv);
2704
void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
2705
				      struct btrfs_block_rsv *rsv);
2706
int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
2707
void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes);
2708 2709
int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);
void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);
2710
void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
2711
struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
2712
					      unsigned short type);
2713
void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
2714
			  struct btrfs_block_rsv *rsv);
2715
void __btrfs_free_block_rsv(struct btrfs_block_rsv *rsv);
2716
int btrfs_block_rsv_add(struct btrfs_root *root,
M
Miao Xie 已提交
2717 2718
			struct btrfs_block_rsv *block_rsv, u64 num_bytes,
			enum btrfs_reserve_flush_enum flush);
2719
int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor);
2720
int btrfs_block_rsv_refill(struct btrfs_root *root,
M
Miao Xie 已提交
2721 2722
			   struct btrfs_block_rsv *block_rsv, u64 min_reserved,
			   enum btrfs_reserve_flush_enum flush);
2723
int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
2724 2725
			    struct btrfs_block_rsv *dst_rsv, u64 num_bytes,
			    int update_size);
2726 2727 2728
int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
			     struct btrfs_block_rsv *dest, u64 num_bytes,
			     int min_factor);
2729
void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
2730 2731
			     struct btrfs_block_rsv *block_rsv,
			     u64 num_bytes);
2732
int btrfs_inc_block_group_ro(struct btrfs_fs_info *fs_info,
2733
			     struct btrfs_block_group_cache *cache);
2734
void btrfs_dec_block_group_ro(struct btrfs_block_group_cache *cache);
2735
void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
2736
u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2737
int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
L
liubo 已提交
2738
				   u64 start, u64 end);
2739
int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2740
			 u64 num_bytes, u64 *actual_bytes);
2741
int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
2742 2743
			    struct btrfs_fs_info *fs_info, u64 type);
int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
L
liubo 已提交
2744

2745
int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
2746 2747
int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info);
2748
int __get_raid_index(u64 flags);
2749 2750
int btrfs_start_write_no_snapshoting(struct btrfs_root *root);
void btrfs_end_write_no_snapshoting(struct btrfs_root *root);
2751
void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
2752
void check_system_chunk(struct btrfs_trans_handle *trans,
2753
			struct btrfs_fs_info *fs_info, const u64 type);
2754 2755 2756
u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
		       struct btrfs_fs_info *info, u64 start, u64 end);

C
Chris Mason 已提交
2757
/* ctree.c */
2758
int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
2759
		     int level, int *slot);
2760
int btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2);
2761 2762 2763
int btrfs_previous_item(struct btrfs_root *root,
			struct btrfs_path *path, u64 min_objectid,
			int type);
2764 2765
int btrfs_previous_extent_item(struct btrfs_root *root,
			struct btrfs_path *path, u64 min_objectid);
2766 2767
void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
			     struct btrfs_path *path,
2768
			     const struct btrfs_key *new_key);
2769 2770
struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2771
int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2772
			struct btrfs_key *key, int lowest_level,
2773
			u64 min_trans);
2774
int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2775
			 struct btrfs_path *path,
2776
			 u64 min_trans);
2777 2778 2779 2780
enum btrfs_compare_tree_result {
	BTRFS_COMPARE_TREE_NEW,
	BTRFS_COMPARE_TREE_DELETED,
	BTRFS_COMPARE_TREE_CHANGED,
2781
	BTRFS_COMPARE_TREE_SAME,
2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792
};
typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root,
				  struct btrfs_root *right_root,
				  struct btrfs_path *left_path,
				  struct btrfs_path *right_path,
				  struct btrfs_key *key,
				  enum btrfs_compare_tree_result result,
				  void *ctx);
int btrfs_compare_trees(struct btrfs_root *left_root,
			struct btrfs_root *right_root,
			btrfs_changed_cb_t cb, void *ctx);
2793 2794 2795
int btrfs_cow_block(struct btrfs_trans_handle *trans,
		    struct btrfs_root *root, struct extent_buffer *buf,
		    struct extent_buffer *parent, int parent_slot,
2796
		    struct extent_buffer **cow_ret);
2797 2798 2799 2800
int btrfs_copy_root(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root,
		      struct extent_buffer *buf,
		      struct extent_buffer **cow_ret, u64 new_root_objectid);
2801 2802
int btrfs_block_can_be_shared(struct btrfs_root *root,
			      struct extent_buffer *buf);
2803
void btrfs_extend_item(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
2804
		       u32 data_size);
2805 2806
void btrfs_truncate_item(struct btrfs_fs_info *fs_info,
			 struct btrfs_path *path, u32 new_size, int from_end);
2807 2808 2809
int btrfs_split_item(struct btrfs_trans_handle *trans,
		     struct btrfs_root *root,
		     struct btrfs_path *path,
2810
		     const struct btrfs_key *new_key,
2811
		     unsigned long split_offset);
Y
Yan, Zheng 已提交
2812 2813 2814
int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
			 struct btrfs_root *root,
			 struct btrfs_path *path,
2815
			 const struct btrfs_key *new_key);
2816 2817
int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
		u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
2818 2819 2820 2821
int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      const struct btrfs_key *key, struct btrfs_path *p,
		      int ins_len, int cow);
int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
J
Jan Schmidt 已提交
2822
			  struct btrfs_path *p, u64 time_seq);
2823
int btrfs_search_slot_for_read(struct btrfs_root *root,
2824 2825 2826
			       const struct btrfs_key *key,
			       struct btrfs_path *p, int find_higher,
			       int return_any);
2827
int btrfs_realloc_node(struct btrfs_trans_handle *trans,
2828
		       struct btrfs_root *root, struct extent_buffer *parent,
2829
		       int start_slot, u64 *last_ret,
2830
		       struct btrfs_key *progress);
2831
void btrfs_release_path(struct btrfs_path *p);
C
Chris Mason 已提交
2832 2833
struct btrfs_path *btrfs_alloc_path(void);
void btrfs_free_path(struct btrfs_path *p);
2834
void btrfs_set_path_blocking(struct btrfs_path *p);
2835
void btrfs_clear_path_blocking(struct btrfs_path *p,
2836
			       struct extent_buffer *held, int held_rw);
2837 2838
void btrfs_unlock_up_safe(struct btrfs_path *p, int level);

2839 2840 2841 2842 2843 2844 2845 2846 2847
int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		   struct btrfs_path *path, int slot, int nr);
static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 struct btrfs_path *path)
{
	return btrfs_del_items(trans, root, path, path->slots[0], 1);
}

2848
void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
2849
			    const struct btrfs_key *cpu_key, u32 *data_size,
2850
			    u32 total_data, u32 total_size, int nr);
2851 2852
int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      const struct btrfs_key *key, void *data, u32 data_size);
2853 2854 2855
int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path,
2856 2857
			     const struct btrfs_key *cpu_key, u32 *data_size,
			     int nr);
2858 2859 2860 2861

static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path,
2862
					  const struct btrfs_key *key,
2863 2864 2865 2866 2867
					  u32 data_size)
{
	return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
}

C
Chris Mason 已提交
2868
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
2869
int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
J
Jan Schmidt 已提交
2870 2871
int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
			u64 time_seq);
2872 2873
static inline int btrfs_next_old_item(struct btrfs_root *root,
				      struct btrfs_path *p, u64 time_seq)
2874 2875 2876
{
	++p->slots[0];
	if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
2877
		return btrfs_next_old_leaf(root, p, time_seq);
2878 2879
	return 0;
}
2880 2881 2882 2883
static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
{
	return btrfs_next_old_item(root, p, 0);
}
2884 2885
int btrfs_leaf_free_space(struct btrfs_fs_info *fs_info,
			  struct extent_buffer *leaf);
2886 2887 2888
int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
				     struct btrfs_block_rsv *block_rsv,
				     int update_ref, int for_reloc);
Y
Yan Zheng 已提交
2889 2890 2891 2892
int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
			struct btrfs_root *root,
			struct extent_buffer *node,
			struct extent_buffer *parent);
2893 2894 2895
static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
{
	/*
2896
	 * Do it this way so we only ever do one test_bit in the normal case.
2897
	 */
2898 2899 2900 2901 2902 2903
	if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
		if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
			return 2;
		return 1;
	}
	return 0;
2904
}
2905 2906 2907 2908 2909 2910

/*
 * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
 * anything except sleeping. This function is used to check the status of
 * the fs.
 */
2911
static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
2912
{
2913
	return fs_info->sb->s_flags & MS_RDONLY || btrfs_fs_closing(fs_info);
2914 2915
}

2916 2917
static inline void free_fs_info(struct btrfs_fs_info *fs_info)
{
2918
	kfree(fs_info->balance_ctl);
2919 2920 2921 2922 2923 2924
	kfree(fs_info->delayed_root);
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
	kfree(fs_info->csum_root);
2925
	kfree(fs_info->quota_root);
2926
	kfree(fs_info->uuid_root);
2927
	kfree(fs_info->free_space_root);
2928 2929
	kfree(fs_info->super_copy);
	kfree(fs_info->super_for_commit);
2930
	security_free_mnt_opts(&fs_info->security_opts);
2931 2932
	kfree(fs_info);
}
2933

2934 2935 2936 2937 2938
/* tree mod log functions from ctree.c */
u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
			   struct seq_list *elem);
void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
			    struct seq_list *elem);
J
Jan Schmidt 已提交
2939
int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
2940

C
Chris Mason 已提交
2941
/* root-item.c */
2942
int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
2943
		       struct btrfs_fs_info *fs_info,
2944 2945 2946
		       u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
		       const char *name, int name_len);
int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
2947
		       struct btrfs_fs_info *fs_info,
2948
		       u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
2949
		       const char *name, int name_len);
2950
int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2951 2952 2953 2954
		   const struct btrfs_key *key);
int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      const struct btrfs_key *key,
		      struct btrfs_root_item *item);
2955 2956 2957 2958
int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct btrfs_key *key,
				   struct btrfs_root_item *item);
2959
int btrfs_find_root(struct btrfs_root *root, const struct btrfs_key *search_key,
2960 2961
		    struct btrfs_path *path, struct btrfs_root_item *root_item,
		    struct btrfs_key *root_key);
2962
int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);
2963 2964
void btrfs_set_root_node(struct btrfs_root_item *item,
			 struct extent_buffer *node);
2965
void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
2966 2967
void btrfs_update_root_times(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root);
2968

2969 2970
/* uuid-tree.c */
int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans,
2971
			struct btrfs_fs_info *fs_info, u8 *uuid, u8 type,
2972 2973
			u64 subid);
int btrfs_uuid_tree_rem(struct btrfs_trans_handle *trans,
2974
			struct btrfs_fs_info *fs_info, u8 *uuid, u8 type,
2975
			u64 subid);
2976 2977 2978
int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
			    int (*check_func)(struct btrfs_fs_info *, u8 *, u8,
					      u64));
2979

C
Chris Mason 已提交
2980
/* dir-item.c */
C
Chris Mason 已提交
2981 2982
int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
			  const char *name, int name_len);
C
Chris Mason 已提交
2983 2984
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, const char *name,
2985
			  int name_len, struct btrfs_inode *dir,
2986
			  struct btrfs_key *location, u8 type, u64 index);
2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
					     struct btrfs_root *root,
					     struct btrfs_path *path, u64 dir,
					     const char *name, int name_len,
					     int mod);
struct btrfs_dir_item *
btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct btrfs_path *path, u64 dir,
			    u64 objectid, const char *name, int name_len,
			    int mod);
2998 2999 3000 3001
struct btrfs_dir_item *
btrfs_search_dir_index_item(struct btrfs_root *root,
			    struct btrfs_path *path, u64 dirid,
			    const char *name, int name_len);
3002 3003 3004 3005
int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct btrfs_path *path,
			      struct btrfs_dir_item *di);
J
Josef Bacik 已提交
3006
int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3007 3008 3009 3010
			    struct btrfs_root *root,
			    struct btrfs_path *path, u64 objectid,
			    const char *name, u16 name_len,
			    const void *data, u16 data_len);
J
Josef Bacik 已提交
3011 3012 3013 3014 3015
struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path, u64 dir,
					  const char *name, u16 name_len,
					  int mod);
3016
int verify_dir_item(struct btrfs_fs_info *fs_info,
3017 3018
		    struct extent_buffer *leaf,
		    struct btrfs_dir_item *dir_item);
3019
struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,
3020 3021 3022
						 struct btrfs_path *path,
						 const char *name,
						 int name_len);
3023 3024 3025 3026 3027 3028

/* orphan.c */
int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root, u64 offset);
int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, u64 offset);
3029
int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3030

C
Chris Mason 已提交
3031
/* inode-item.c */
3032 3033 3034
int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root,
			   const char *name, int name_len,
3035
			   u64 inode_objectid, u64 ref_objectid, u64 index);
3036 3037 3038
int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root,
			   const char *name, int name_len,
3039
			   u64 inode_objectid, u64 ref_objectid, u64 *index);
3040 3041 3042
int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid);
3043
int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
3044 3045
		       *root, struct btrfs_path *path,
		       struct btrfs_key *location, int mod);
C
Chris Mason 已提交
3046

M
Mark Fasheh 已提交
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059
struct btrfs_inode_extref *
btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root,
			  struct btrfs_path *path,
			  const char *name, int name_len,
			  u64 inode_objectid, u64 ref_objectid, int ins_len,
			  int cow);

int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
				   u64 ref_objectid, const char *name,
				   int name_len,
				   struct btrfs_inode_extref **extref_ret);

C
Chris Mason 已提交
3060
/* file-item.c */
3061
struct btrfs_dio_private;
3062
int btrfs_del_csums(struct btrfs_trans_handle *trans,
3063
		    struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
3064 3065 3066
int btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst);
int btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio,
			      u64 logical_offset);
C
Chris Mason 已提交
3067
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
3068 3069 3070 3071 3072
			     struct btrfs_root *root,
			     u64 objectid, u64 pos,
			     u64 disk_offset, u64 disk_num_bytes,
			     u64 num_bytes, u64 offset, u64 ram_bytes,
			     u8 compression, u8 encryption, u16 other_encoding);
C
Chris Mason 已提交
3073 3074 3075
int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid,
3076
			     u64 bytenr, int mod);
3077
int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3078
			   struct btrfs_root *root,
3079
			   struct btrfs_ordered_sum *sums);
3080 3081
int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
		       u64 file_start, int contig);
A
Arne Jansen 已提交
3082 3083
int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
			     struct list_head *list, int search_commit);
3084 3085 3086 3087 3088 3089
void btrfs_extent_item_to_extent_map(struct inode *inode,
				     const struct btrfs_path *path,
				     struct btrfs_file_extent_item *fi,
				     const bool new_inline,
				     struct extent_map *em);

C
Chris Mason 已提交
3090
/* inode.c */
3091 3092 3093 3094 3095 3096 3097 3098 3099
struct btrfs_delalloc_work {
	struct inode *inode;
	int delay_iput;
	struct completion completion;
	struct list_head list;
	struct btrfs_work work;
};

struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
3100
						    int delay_iput);
3101 3102
void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);

J
Josef Bacik 已提交
3103 3104 3105
struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
					   size_t pg_offset, u64 start, u64 len,
					   int create);
3106
noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
3107 3108
			      u64 *orig_start, u64 *orig_block_len,
			      u64 *ram_bytes);
3109 3110

/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
3111
#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
3112 3113 3114 3115 3116
#define ClearPageChecked ClearPageFsMisc
#define SetPageChecked SetPageFsMisc
#define PageChecked PageFsMisc
#endif

L
Li Zefan 已提交
3117 3118 3119 3120 3121 3122 3123 3124
/* This forces readahead on a given range of bytes in an inode */
static inline void btrfs_force_ra(struct address_space *mapping,
				  struct file_ra_state *ra, struct file *file,
				  pgoff_t offset, unsigned long req_size)
{
	page_cache_sync_readahead(mapping, ra, file, offset, req_size);
}

3125
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3126
int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
3127 3128
int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root,
3129
		       struct btrfs_inode *dir, struct btrfs_inode *inode,
3130 3131 3132 3133
		       const char *name, int name_len);
int btrfs_add_link(struct btrfs_trans_handle *trans,
		   struct inode *parent_inode, struct inode *inode,
		   const char *name, int name_len, int add_backref, u64 index);
3134 3135 3136 3137
int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
			struct btrfs_root *root,
			struct inode *dir, u64 objectid,
			const char *name, int name_len);
3138
int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
J
Josef Bacik 已提交
3139
			int front);
3140 3141 3142 3143 3144
int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
			       struct inode *inode, u64 new_size,
			       u32 min_type);

Y
Yan, Zheng 已提交
3145
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
3146 3147
int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput,
			       int nr);
3148
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3149
			      struct extent_state **cached_state, int dedupe);
3150
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3151 3152 3153
			     struct btrfs_root *new_root,
			     struct btrfs_root *parent_root,
			     u64 new_dirid);
3154
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
3155 3156
			 size_t size, struct bio *bio,
			 unsigned long bio_flags);
3157
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
C
Chris Mason 已提交
3158
int btrfs_readpage(struct file *file, struct page *page);
A
Al Viro 已提交
3159
void btrfs_evict_inode(struct inode *inode);
3160
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
C
Chris Mason 已提交
3161 3162
struct inode *btrfs_alloc_inode(struct super_block *sb);
void btrfs_destroy_inode(struct inode *inode);
3163
int btrfs_drop_inode(struct inode *inode);
C
Chris Mason 已提交
3164 3165
int btrfs_init_cachep(void);
void btrfs_destroy_cachep(void);
S
Sage Weil 已提交
3166
long btrfs_ioctl_trans_end(struct file *file);
B
Balaji Rao 已提交
3167
struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3168
			 struct btrfs_root *root, int *was_new);
3169
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3170
				    size_t pg_offset, u64 start, u64 end,
3171 3172 3173 3174
				    int create);
int btrfs_update_inode(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct inode *inode);
3175 3176
int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode);
3177
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
3178
int btrfs_orphan_cleanup(struct btrfs_root *root);
3179 3180
void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root);
3181
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3182
void btrfs_invalidate_inodes(struct btrfs_root *root);
Y
Yan, Zheng 已提交
3183
void btrfs_add_delayed_iput(struct inode *inode);
3184
void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
3185 3186 3187
int btrfs_prealloc_file_range(struct inode *inode, int mode,
			      u64 start, u64 num_bytes, u64 min_size,
			      loff_t actual_len, u64 *alloc_hint);
3188 3189 3190 3191
int btrfs_prealloc_file_range_trans(struct inode *inode,
				    struct btrfs_trans_handle *trans, int mode,
				    u64 start, u64 num_bytes, u64 min_size,
				    loff_t actual_len, u64 *alloc_hint);
3192
extern const struct dentry_operations btrfs_dentry_operations;
3193 3194 3195
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
void btrfs_test_inode_set_ops(struct inode *inode);
#endif
C
Christoph Hellwig 已提交
3196 3197 3198

/* ioctl.c */
long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3199
long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3200
int btrfs_ioctl_get_supported_features(void __user *arg);
3201 3202
void btrfs_update_iflags(struct inode *inode);
void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
3203
int btrfs_is_empty_uuid(u8 *uuid);
C
Chris Mason 已提交
3204 3205 3206
int btrfs_defrag_file(struct inode *inode, struct file *file,
		      struct btrfs_ioctl_defrag_range_args *range,
		      u64 newer_than, unsigned long max_pages);
3207 3208
void btrfs_get_block_group_info(struct list_head *groups_list,
				struct btrfs_ioctl_space_info *space);
3209 3210
void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
			       struct btrfs_ioctl_balance_args *bargs);
3211 3212
ssize_t btrfs_dedupe_file_range(struct file *src_file, u64 loff, u64 olen,
			   struct file *dst_file, u64 dst_loff);
3213

C
Chris Mason 已提交
3214
/* file.c */
3215 3216
int btrfs_auto_defrag_init(void);
void btrfs_auto_defrag_exit(void);
C
Chris Mason 已提交
3217
int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3218
			   struct btrfs_inode *inode);
C
Chris Mason 已提交
3219
int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3220
void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
3221
int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3222 3223
void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
			     int skip_pinned);
3224
extern const struct file_operations btrfs_file_operations;
J
Josef Bacik 已提交
3225 3226 3227
int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
			 struct btrfs_root *root, struct inode *inode,
			 struct btrfs_path *path, u64 start, u64 end,
3228 3229 3230 3231
			 u64 *drop_end, int drop_cache,
			 int replace_extent,
			 u32 extent_item_size,
			 int *key_inserted);
J
Josef Bacik 已提交
3232 3233
int btrfs_drop_extents(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root, struct inode *inode, u64 start,
3234
		       u64 end, int drop_cache);
Y
Yan Zheng 已提交
3235 3236
int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
			      struct inode *inode, u64 start, u64 end);
S
Sage Weil 已提交
3237
int btrfs_release_file(struct inode *inode, struct file *file);
3238 3239
int btrfs_dirty_pages(struct inode *inode, struct page **pages,
		      size_t num_pages, loff_t pos, size_t write_bytes,
3240
		      struct extent_state **cached);
3241
int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
3242 3243
int btrfs_clone_file_range(struct file *file_in, loff_t pos_in,
			   struct file *file_out, loff_t pos_out, u64 len);
S
Sage Weil 已提交
3244

3245 3246
/* tree-defrag.c */
int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3247
			struct btrfs_root *root);
3248 3249 3250 3251

/* sysfs.c */
int btrfs_init_sysfs(void);
void btrfs_exit_sysfs(void);
3252
int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info);
3253
void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info);
3254

J
Josef Bacik 已提交
3255 3256
/* xattr.c */
ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
J
Josef Bacik 已提交
3257

3258
/* super.c */
3259
int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
3260
			unsigned long new_flags);
S
Sage Weil 已提交
3261
int btrfs_sync_fs(struct super_block *sb, int wait);
3262

3263 3264 3265 3266 3267
static inline __printf(2, 3)
void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
{
}

3268 3269
#ifdef CONFIG_PRINTK
__printf(2, 3)
3270
void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3271
#else
3272 3273
#define btrfs_printk(fs_info, fmt, args...) \
	btrfs_no_printk(fs_info, fmt, ##args)
3274 3275
#endif

3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
#define btrfs_emerg(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
#define btrfs_alert(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
#define btrfs_crit(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
#define btrfs_err(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_ERR fmt, ##args)
#define btrfs_warn(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
#define btrfs_notice(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
#define btrfs_info(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_INFO fmt, ##args)
3290

3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
/*
 * Wrappers that use printk_in_rcu
 */
#define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
#define btrfs_alert_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
#define btrfs_crit_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
#define btrfs_err_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
#define btrfs_warn_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
#define btrfs_notice_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
#define btrfs_info_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)

3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326
/*
 * Wrappers that use a ratelimited printk_in_rcu
 */
#define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
#define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
#define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
#define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
#define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
#define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
#define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)

3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343
/*
 * Wrappers that use a ratelimited printk
 */
#define btrfs_emerg_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
#define btrfs_alert_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
#define btrfs_crit_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
#define btrfs_err_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
#define btrfs_warn_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
#define btrfs_notice_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
#define btrfs_info_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
J
Jeff Mahoney 已提交
3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372

#if defined(CONFIG_DYNAMIC_DEBUG)
#define btrfs_debug(fs_info, fmt, args...)				\
do {									\
        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
		btrfs_printk(fs_info, KERN_DEBUG fmt, ##args);		\
} while (0)
#define btrfs_debug_in_rcu(fs_info, fmt, args...) 			\
do {									\
        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); 	        \
        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) 		\
		btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args);	\
} while (0)
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...)			\
do {									\
        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
		btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt,		\
				       ##args);\
} while (0)
#define btrfs_debug_rl(fs_info, fmt, args...) 				\
do {									\
        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         	\
        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  	\
		btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt,	\
					 ##args);			\
} while (0)
#elif defined(DEBUG)
3373 3374
#define btrfs_debug(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3375 3376
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3377 3378
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3379 3380
#define btrfs_debug_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
3381 3382
#else
#define btrfs_debug(fs_info, fmt, args...) \
3383
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3384
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3385
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3386
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3387
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3388
#define btrfs_debug_rl(fs_info, fmt, args...) \
3389
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3390
#endif
3391

3392 3393 3394 3395 3396 3397 3398
#define btrfs_printk_in_rcu(fs_info, fmt, args...)	\
do {							\
	rcu_read_lock();				\
	btrfs_printk(fs_info, fmt, ##args);		\
	rcu_read_unlock();				\
} while (0)

3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
#define btrfs_printk_ratelimited(fs_info, fmt, args...)		\
do {								\
	static DEFINE_RATELIMIT_STATE(_rs,			\
		DEFAULT_RATELIMIT_INTERVAL,			\
		DEFAULT_RATELIMIT_BURST);       		\
	if (__ratelimit(&_rs))					\
		btrfs_printk(fs_info, fmt, ##args);		\
} while (0)

#define btrfs_printk_rl_in_rcu(fs_info, fmt, args...)		\
do {								\
	rcu_read_lock();					\
	btrfs_printk_ratelimited(fs_info, fmt, ##args);		\
	rcu_read_unlock();					\
} while (0)

J
Josef Bacik 已提交
3415 3416
#ifdef CONFIG_BTRFS_ASSERT

3417
__cold
J
Josef Bacik 已提交
3418 3419
static inline void assfail(char *expr, char *file, int line)
{
3420
	pr_err("assertion failed: %s, file: %s, line: %d\n",
J
Josef Bacik 已提交
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
	       expr, file, line);
	BUG();
}

#define ASSERT(expr)	\
	(likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
#else
#define ASSERT(expr)	((void)0)
#endif

3431
__printf(5, 6)
3432
__cold
3433
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
J
Jeff Mahoney 已提交
3434
		     unsigned int line, int errno, const char *fmt, ...);
L
liubo 已提交
3435

3436
const char *btrfs_decode_error(int errno);
3437

3438
__cold
3439
void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3440
			       const char *function,
3441 3442
			       unsigned int line, int errno);

3443 3444 3445 3446
/*
 * Call btrfs_abort_transaction as early as possible when an error condition is
 * detected, that way the exact line number is reported.
 */
3447
#define btrfs_abort_transaction(trans, errno)		\
3448 3449 3450
do {								\
	/* Report first abort since mount */			\
	if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,	\
3451
			&((trans)->fs_info->fs_state))) {	\
3452 3453 3454 3455 3456
		if ((errno) != -EIO) {				\
			WARN(1, KERN_DEBUG				\
			"BTRFS: Transaction aborted (error %d)\n",	\
			(errno));					\
		} else {						\
3457 3458
			btrfs_debug((trans)->fs_info,			\
				    "Transaction aborted (error %d)", \
3459 3460
				  (errno));			\
		}						\
3461
	}							\
3462
	__btrfs_abort_transaction((trans), __func__,		\
3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488
				  __LINE__, (errno));		\
} while (0)

#define btrfs_handle_fs_error(fs_info, errno, fmt, args...)		\
do {								\
	__btrfs_handle_fs_error((fs_info), __func__, __LINE__,	\
			  (errno), fmt, ##args);		\
} while (0)

__printf(5, 6)
__cold
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int errno, const char *fmt, ...);
/*
 * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
 * will panic().  Otherwise we BUG() here.
 */
#define btrfs_panic(fs_info, errno, fmt, args...)			\
do {									\
	__btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args);	\
	BUG();								\
} while (0)


/* compatibility and incompatibility defines */

3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
#define btrfs_set_fs_incompat(__fs_info, opt) \
	__btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
					   u64 flag)
{
	struct btrfs_super_block *disk_super;
	u64 features;

	disk_super = fs_info->super_copy;
	features = btrfs_super_incompat_flags(disk_super);
	if (!(features & flag)) {
3501 3502 3503 3504 3505
		spin_lock(&fs_info->super_lock);
		features = btrfs_super_incompat_flags(disk_super);
		if (!(features & flag)) {
			features |= flag;
			btrfs_set_super_incompat_flags(disk_super, features);
3506
			btrfs_info(fs_info, "setting %llu feature flag",
3507 3508 3509
					 flag);
		}
		spin_unlock(&fs_info->super_lock);
3510 3511 3512
	}
}

3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
#define btrfs_clear_fs_incompat(__fs_info, opt) \
	__btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
					     u64 flag)
{
	struct btrfs_super_block *disk_super;
	u64 features;

	disk_super = fs_info->super_copy;
	features = btrfs_super_incompat_flags(disk_super);
	if (features & flag) {
		spin_lock(&fs_info->super_lock);
		features = btrfs_super_incompat_flags(disk_super);
		if (features & flag) {
			features &= ~flag;
			btrfs_set_super_incompat_flags(disk_super, features);
			btrfs_info(fs_info, "clearing %llu feature flag",
					 flag);
		}
		spin_unlock(&fs_info->super_lock);
	}
}

3537 3538 3539
#define btrfs_fs_incompat(fs_info, opt) \
	__btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

3540
static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3541 3542 3543 3544 3545 3546
{
	struct btrfs_super_block *disk_super;
	disk_super = fs_info->super_copy;
	return !!(btrfs_super_incompat_flags(disk_super) & flag);
}

3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604
#define btrfs_set_fs_compat_ro(__fs_info, opt) \
	__btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)

static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
					    u64 flag)
{
	struct btrfs_super_block *disk_super;
	u64 features;

	disk_super = fs_info->super_copy;
	features = btrfs_super_compat_ro_flags(disk_super);
	if (!(features & flag)) {
		spin_lock(&fs_info->super_lock);
		features = btrfs_super_compat_ro_flags(disk_super);
		if (!(features & flag)) {
			features |= flag;
			btrfs_set_super_compat_ro_flags(disk_super, features);
			btrfs_info(fs_info, "setting %llu ro feature flag",
				   flag);
		}
		spin_unlock(&fs_info->super_lock);
	}
}

#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
	__btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)

static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
					      u64 flag)
{
	struct btrfs_super_block *disk_super;
	u64 features;

	disk_super = fs_info->super_copy;
	features = btrfs_super_compat_ro_flags(disk_super);
	if (features & flag) {
		spin_lock(&fs_info->super_lock);
		features = btrfs_super_compat_ro_flags(disk_super);
		if (features & flag) {
			features &= ~flag;
			btrfs_set_super_compat_ro_flags(disk_super, features);
			btrfs_info(fs_info, "clearing %llu ro feature flag",
				   flag);
		}
		spin_unlock(&fs_info->super_lock);
	}
}

#define btrfs_fs_compat_ro(fs_info, opt) \
	__btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)

static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
{
	struct btrfs_super_block *disk_super;
	disk_super = fs_info->super_copy;
	return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
}

J
Josef Bacik 已提交
3605
/* acl.c */
C
Chris Mason 已提交
3606
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
3607
struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3608
int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
3609 3610
int btrfs_init_acl(struct btrfs_trans_handle *trans,
		   struct inode *inode, struct inode *dir);
3611
#else
3612
#define btrfs_get_acl NULL
3613
#define btrfs_set_acl NULL
3614 3615 3616 3617 3618 3619
static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
				 struct inode *inode, struct inode *dir)
{
	return 0;
}
#endif
J
Josef Bacik 已提交
3620

3621
/* relocation.c */
3622
int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
3623 3624 3625 3626 3627 3628
int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root);
int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root);
int btrfs_recover_relocation(struct btrfs_root *root);
int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
3629 3630 3631
int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, struct extent_buffer *buf,
			  struct extent_buffer *cow);
3632
void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
3633
			      u64 *bytes_to_reserve);
3634
int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3635
			      struct btrfs_pending_snapshot *pending);
A
Arne Jansen 已提交
3636 3637

/* scrub.c */
3638 3639
int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
		    u64 end, struct btrfs_scrub_progress *progress,
3640
		    int readonly, int is_dev_replace);
3641 3642
void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3643 3644 3645
int btrfs_scrub_cancel(struct btrfs_fs_info *info);
int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
			   struct btrfs_device *dev);
3646
int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
A
Arne Jansen 已提交
3647
			 struct btrfs_scrub_progress *progress);
3648 3649 3650 3651

/* dev-replace.c */
void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
3652 3653 3654 3655 3656 3657
void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);

static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
{
	btrfs_bio_counter_sub(fs_info, 1);
}
A
Arne Jansen 已提交
3658

3659 3660
/* reada.c */
struct reada_control {
3661
	struct btrfs_fs_info	*fs_info;		/* tree to prefetch */
3662 3663 3664 3665 3666 3667 3668 3669 3670 3671
	struct btrfs_key	key_start;
	struct btrfs_key	key_end;	/* exclusive */
	atomic_t		elems;
	struct kref		refcnt;
	wait_queue_head_t	wait;
};
struct reada_control *btrfs_reada_add(struct btrfs_root *root,
			      struct btrfs_key *start, struct btrfs_key *end);
int btrfs_reada_wait(void *handle);
void btrfs_reada_detach(void *handle);
3672
int btree_readahead_hook(struct btrfs_fs_info *fs_info,
3673
			 struct extent_buffer *eb, int err);
3674

3675 3676 3677
static inline int is_fstree(u64 rootid)
{
	if (rootid == BTRFS_FS_TREE_OBJECTID ||
3678 3679
	    ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
	      !btrfs_qgroup_level(rootid)))
3680 3681 3682
		return 1;
	return 0;
}
3683 3684 3685 3686 3687 3688

static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
{
	return signal_pending(current);
}

3689 3690 3691 3692
/* Sanity test specific functions */
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
void btrfs_test_destroy_inode(struct inode *inode);
#endif
3693

3694
static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3695 3696
{
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3697 3698
	if (unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO,
			      &fs_info->fs_state)))
3699 3700 3701 3702
		return 1;
#endif
	return 0;
}
3703
#endif