ctree.h 125.6 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 108 109 110
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 已提交
111 112 113
/*
 * File system states
 */
114
#define BTRFS_FS_STATE_ERROR		0
M
Miao Xie 已提交
115
#define BTRFS_FS_STATE_REMOUNTING	1
116
#define BTRFS_FS_STATE_TRANS_ABORTED	2
117
#define BTRFS_FS_STATE_DEV_REPLACING	3
118
#define BTRFS_FS_STATE_DUMMY_FS_INFO	4
L
liubo 已提交
119

120 121 122 123 124 125 126
#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
127

128 129 130
/*
 * every tree block (leaf or node) starts with this header.
 */
131
struct btrfs_header {
132
	/* these first four must match the super block */
C
Chris Mason 已提交
133
	u8 csum[BTRFS_CSUM_SIZE];
134
	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
135
	__le64 bytenr; /* which block this node is supposed to live in */
136
	__le64 flags;
137 138 139

	/* allowed to be different from the super from here on down */
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
140
	__le64 generation;
141
	__le64 owner;
142
	__le32 nritems;
143
	u8 level;
144 145
} __attribute__ ((__packed__));

146 147 148 149 150 151
/*
 * 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 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
/*
 * 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 已提交
181
	__le64 unused_64[4];
C
Chris Mason 已提交
182 183 184 185 186 187 188 189 190 191 192

	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__));

193 194 195 196
/*
 * the super block basically lists the main trees of the FS
 * it currently lacks any block count etc etc
 */
C
Chris Mason 已提交
197
struct btrfs_super_block {
C
Chris Mason 已提交
198
	u8 csum[BTRFS_CSUM_SIZE];
199
	/* the first 4 fields must match struct btrfs_header */
Y
Yan Zheng 已提交
200
	u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
201
	__le64 bytenr; /* this block number */
202
	__le64 flags;
203 204

	/* allowed to be different from the btrfs_header from here own down */
205 206 207
	__le64 magic;
	__le64 generation;
	__le64 root;
208
	__le64 chunk_root;
209
	__le64 log_root;
210 211 212

	/* this will help find the new super based on the log root */
	__le64 log_root_transid;
213 214
	__le64 total_bytes;
	__le64 bytes_used;
215
	__le64 root_dir_objectid;
216
	__le64 num_devices;
217 218
	__le32 sectorsize;
	__le32 nodesize;
219
	__le32 __unused_leafsize;
220
	__le32 stripesize;
221
	__le32 sys_chunk_array_size;
222
	__le64 chunk_root_generation;
223 224 225
	__le64 compat_flags;
	__le64 compat_ro_flags;
	__le64 incompat_flags;
226
	__le16 csum_type;
227
	u8 root_level;
228
	u8 chunk_root_level;
229
	u8 log_root_level;
230
	struct btrfs_dev_item dev_item;
231

232
	char label[BTRFS_LABEL_SIZE];
233

234
	__le64 cache_generation;
235
	__le64 uuid_tree_generation;
236

237
	/* future expansion */
238
	__le64 reserved[30];
239
	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
C
Chris Mason 已提交
240
	struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
C
Chris Mason 已提交
241 242
} __attribute__ ((__packed__));

243 244 245 246
/*
 * Compat flags that we support.  If any incompat flags are set other than the
 * ones specified below then we will fail to mount
 */
247
#define BTRFS_FEATURE_COMPAT_SUPP		0ULL
248 249
#define BTRFS_FEATURE_COMPAT_SAFE_SET		0ULL
#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR		0ULL
250 251

#define BTRFS_FEATURE_COMPAT_RO_SUPP			\
252 253
	(BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |	\
	 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
254

255 256 257
#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET	0ULL
#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR	0ULL

258 259
#define BTRFS_FEATURE_INCOMPAT_SUPP			\
	(BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |		\
260
	 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |	\
L
Li Zefan 已提交
261
	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |		\
262
	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
M
Mark Fasheh 已提交
263
	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
D
David Woodhouse 已提交
264
	 BTRFS_FEATURE_INCOMPAT_RAID56 |		\
265
	 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |		\
266 267
	 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |	\
	 BTRFS_FEATURE_INCOMPAT_NO_HOLES)
268

269 270 271
#define BTRFS_FEATURE_INCOMPAT_SAFE_SET			\
	(BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR		0ULL
272

273
/*
274
 * A leaf is full of items. offset and size tell us where to find
275 276
 * the item in the leaf (relative to the start of the data area)
 */
C
Chris Mason 已提交
277
struct btrfs_item {
C
Chris Mason 已提交
278
	struct btrfs_disk_key key;
C
Chris Mason 已提交
279
	__le32 offset;
280
	__le32 size;
281 282
} __attribute__ ((__packed__));

283 284 285 286 287 288 289
/*
 * 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 已提交
290
struct btrfs_leaf {
291
	struct btrfs_header header;
C
Chris Mason 已提交
292
	struct btrfs_item items[];
293 294
} __attribute__ ((__packed__));

295 296 297 298
/*
 * all non-leaf blocks are nodes, they hold only keys and pointers to
 * other blocks
 */
C
Chris Mason 已提交
299 300 301
struct btrfs_key_ptr {
	struct btrfs_disk_key key;
	__le64 blockptr;
302
	__le64 generation;
C
Chris Mason 已提交
303 304
} __attribute__ ((__packed__));

C
Chris Mason 已提交
305
struct btrfs_node {
306
	struct btrfs_header header;
C
Chris Mason 已提交
307
	struct btrfs_key_ptr ptrs[];
308 309
} __attribute__ ((__packed__));

310
/*
C
Chris Mason 已提交
311 312
 * 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
313 314 315 316 317
 * to any other levels that are present.
 *
 * The slots array records the index of the item or block pointer
 * used while walking the tree.
 */
318
enum { READA_NONE = 0, READA_BACK, READA_FORWARD };
C
Chris Mason 已提交
319
struct btrfs_path {
320
	struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
C
Chris Mason 已提交
321
	int slots[BTRFS_MAX_LEVEL];
322
	/* if there is real range locking, this locks field will change */
323
	u8 locks[BTRFS_MAX_LEVEL];
324
	u8 reada;
325
	/* keep some upper locks as we walk down */
326
	u8 lowest_level;
327 328 329 330 331

	/*
	 * set by btrfs_split_item, tells search_slot to keep all locks
	 * and to force calls to keep space in the nodes
	 */
332 333 334 335
	unsigned int search_for_split:1;
	unsigned int keep_locks:1;
	unsigned int skip_locking:1;
	unsigned int leave_spinning:1;
336
	unsigned int search_commit_root:1;
337
	unsigned int need_commit_sem:1;
338
	unsigned int skip_release_on_error:1;
339
};
340
#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
341
					sizeof(struct btrfs_item))
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
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;
364 365 366 367
	rwlock_t lock;
	atomic_t read_locks;
	atomic_t blocking_readers;
	wait_queue_head_t read_lock_wq;
368 369 370 371

	struct btrfs_scrub_progress scrub_progress;
};

372 373 374 375 376 377
/* For raid type sysfs entries */
struct raid_kobject {
	int raid_type;
	struct kobject kobj;
};

378
struct btrfs_space_info {
379
	spinlock_t lock;
J
Josef Bacik 已提交
380

J
Josef Bacik 已提交
381 382
	u64 total_bytes;	/* total bytes in the space,
				   this doesn't take mirrors into account */
383
	u64 bytes_used;		/* total bytes used,
384
				   this doesn't take mirrors into account */
J
Josef Bacik 已提交
385 386 387 388 389
	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 已提交
390
				   delalloc/allocations */
391 392
	u64 bytes_readonly;	/* total bytes that are read only */

393 394 395 396
	u64 max_extent_size;	/* This will hold the maximum extent size of
				   the space info if we had an ENOSPC in the
				   allocator. */

397 398 399 400 401 402 403 404 405
	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 */

406
	u64 disk_used;		/* total bytes used on disk */
J
Josef Bacik 已提交
407 408
	u64 disk_total;		/* total bytes on disk, takes mirrors into
				   account */
J
Josef Bacik 已提交
409

410 411
	u64 flags;

412 413 414 415 416
	/*
	 * 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
417 418
	 * 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
419
	 * freed once the transaction is committed.  It will be zeroed every
420
	 * time the transaction commits.
421 422 423
	 */
	struct percpu_counter total_bytes_pinned;

424
	struct list_head list;
425
	/* Protected by the spinlock 'lock'. */
426
	struct list_head ro_bgs;
427 428
	struct list_head priority_tickets;
	struct list_head tickets;
429 430 431 432
	/*
	 * tickets_id just indicates the next ticket will be handled, so note
	 * it's not stored per ticket.
	 */
433
	u64 tickets_id;
J
Josef Bacik 已提交
434

435
	struct rw_semaphore groups_sem;
J
Josef Bacik 已提交
436
	/* for block groups in our same type */
437
	struct list_head block_groups[BTRFS_NR_RAID_TYPES];
438
	wait_queue_head_t wait;
439 440

	struct kobject kobj;
441
	struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
J
Josef Bacik 已提交
442 443
};

444 445 446 447 448 449 450 451
#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

452 453 454 455 456
struct btrfs_block_rsv {
	u64 size;
	u64 reserved;
	struct btrfs_space_info *space_info;
	spinlock_t lock;
457 458 459
	unsigned short full;
	unsigned short type;
	unsigned short failfast;
460 461
};

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
/*
 * 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;

478 479 480
	/* We did a full search and couldn't create a cluster */
	bool fragmented;

481 482 483 484 485 486 487
	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;
488 489
};

J
Josef Bacik 已提交
490 491 492
enum btrfs_caching_type {
	BTRFS_CACHE_NO		= 0,
	BTRFS_CACHE_STARTED	= 1,
493 494
	BTRFS_CACHE_FAST	= 2,
	BTRFS_CACHE_FINISHED	= 3,
495
	BTRFS_CACHE_ERROR	= 4,
J
Josef Bacik 已提交
496 497
};

498 499 500 501 502 503 504
enum btrfs_disk_cache_state {
	BTRFS_DC_WRITTEN	= 0,
	BTRFS_DC_ERROR		= 1,
	BTRFS_DC_CLEAR		= 2,
	BTRFS_DC_SETUP		= 3,
};

505 506 507 508
struct btrfs_caching_control {
	struct list_head list;
	struct mutex mutex;
	wait_queue_head_t wait;
509
	struct btrfs_work work;
510 511 512 513 514
	struct btrfs_block_group_cache *block_group;
	u64 progress;
	atomic_t count;
};

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

518 519 520 521
struct btrfs_io_ctl {
	void *cur, *orig;
	struct page *page;
	struct page **pages;
522
	struct btrfs_fs_info *fs_info;
523
	struct inode *inode;
524 525 526
	unsigned long size;
	int index;
	int num_pages;
527 528
	int entries;
	int bitmaps;
529 530 531
	unsigned check_crcs:1;
};

C
Chris Mason 已提交
532 533 534
struct btrfs_block_group_cache {
	struct btrfs_key key;
	struct btrfs_block_group_item item;
J
Josef Bacik 已提交
535
	struct btrfs_fs_info *fs_info;
536
	struct inode *inode;
537
	spinlock_t lock;
538
	u64 pinned;
539
	u64 reserved;
540
	u64 delalloc_bytes;
541
	u64 bytes_super;
542
	u64 flags;
543
	u64 cache_generation;
544 545 546 547 548 549 550 551 552 553 554 555 556
	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 已提交
557

558 559 560 561 562 563 564
	/*
	 * 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 已提交
565 566 567
	/* for raid56, this is a full stripe, without parity */
	unsigned long full_stripe_len;

568
	unsigned int ro;
569
	unsigned int iref:1;
570
	unsigned int has_caching_ctl:1;
571
	unsigned int removed:1;
572 573

	int disk_cache_state;
J
Josef Bacik 已提交
574

J
Josef Bacik 已提交
575 576
	/* cache tracking stuff */
	int cached;
577 578
	struct btrfs_caching_control *caching_ctl;
	u64 last_byte_to_unpin;
J
Josef Bacik 已提交
579

J
Josef Bacik 已提交
580 581 582
	struct btrfs_space_info *space_info;

	/* free space cache stuff */
583
	struct btrfs_free_space_ctl *free_space_ctl;
J
Josef Bacik 已提交
584 585 586 587 588 589

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

	/* for block groups in the same raid type */
	struct list_head list;
590 591 592

	/* usage count */
	atomic_t count;
593 594 595 596 597

	/* 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;
598

599 600
	/* For delayed block group creation or deletion of empty block groups */
	struct list_head bg_list;
601 602 603

	/* For read-only block groups */
	struct list_head ro_list;
604 605

	atomic_t trimming;
606 607 608

	/* For dirty block groups */
	struct list_head dirty_list;
609 610 611
	struct list_head io_list;

	struct btrfs_io_ctl io_ctl;
612

613 614 615 616 617 618 619 620 621 622 623
	/*
	 * 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;

624 625 626 627 628 629 630 631 632 633
	/*
	 * 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;

634 635 636 637 638 639 640 641
	/* 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 已提交
642
};
643

644 645 646 647 648 649
/* delayed seq elem */
struct seq_list {
	struct list_head list;
	u64 seq;
};

650 651
#define SEQ_LIST_INIT(name)	{ .list = LIST_HEAD_INIT((name).list), .seq = 0 }

652 653 654 655 656
enum btrfs_orphan_cleanup_state {
	ORPHAN_CLEANUP_STARTED	= 1,
	ORPHAN_CLEANUP_DONE	= 2,
};

D
David Woodhouse 已提交
657 658 659 660 661 662 663 664 665
/* 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 {
666 667 668 669
	struct list_head stripe_cache;
	spinlock_t cache_lock;
	int cache_size;
	struct btrfs_stripe_hash table[];
D
David Woodhouse 已提交
670 671 672 673
};

#define BTRFS_STRIPE_HASH_TABLE_BITS 11

674 675
void btrfs_init_async_reclaim_work(struct work_struct *work);

676
/* fs_info */
677
struct reloc_control;
678
struct btrfs_device;
679
struct btrfs_fs_devices;
680
struct btrfs_balance_control;
681
struct btrfs_delayed_root;
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696

#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

697
struct btrfs_fs_info {
698
	u8 fsid[BTRFS_FSID_SIZE];
699
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
700
	unsigned long flags;
701 702
	struct btrfs_root *extent_root;
	struct btrfs_root *tree_root;
703 704
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
705
	struct btrfs_root *fs_root;
706
	struct btrfs_root *csum_root;
707
	struct btrfs_root *quota_root;
708
	struct btrfs_root *uuid_root;
709
	struct btrfs_root *free_space_root;
710 711 712

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

	spinlock_t fs_roots_radix_lock;
715
	struct radix_tree_root fs_roots_radix;
716

J
Josef Bacik 已提交
717 718
	/* block group cache stuff */
	spinlock_t block_group_cache_lock;
719
	u64 first_logical_byte;
J
Josef Bacik 已提交
720 721
	struct rb_root block_group_cache_tree;

722 723 724 725
	/* keep track of unallocated space */
	spinlock_t free_chunk_lock;
	u64 free_chunk_space;

726 727
	struct extent_io_tree freed_extents[2];
	struct extent_io_tree *pinned_extents;
728

729 730 731
	/* logical->physical extent mapping */
	struct btrfs_mapping_tree mapping_tree;

732 733 734 735
	/*
	 * block reservation for extent, checksum, root tree and
	 * delayed dir index item
	 */
736 737 738 739 740 741 742
	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;
743 744
	/* block reservation for delayed operations */
	struct btrfs_block_rsv delayed_block_rsv;
745 746 747

	struct btrfs_block_rsv empty_block_rsv;

748
	u64 generation;
749
	u64 last_trans_committed;
750
	u64 avg_delayed_ref_runtime;
751 752 753 754 755 756

	/*
	 * 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;
757
	unsigned long mount_opt;
758 759 760 761 762
	/*
	 * Track requests for actions that need to be done during transaction
	 * commit (like for some mount options).
	 */
	unsigned long pending_changes;
763
	unsigned long compress_type:4;
764
	int commit_interval;
765 766 767 768 769 770
	/*
	 * 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.
	 */
771
	u64 max_inline;
M
Miao Xie 已提交
772 773 774 775 776 777 778 779 780 781
	/*
	 * 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.
	 */
782
	u64 alloc_start;
C
Chris Mason 已提交
783
	struct btrfs_transaction *running_transaction;
784
	wait_queue_head_t transaction_throttle;
785
	wait_queue_head_t transaction_wait;
S
Sage Weil 已提交
786
	wait_queue_head_t transaction_blocked_wait;
787
	wait_queue_head_t async_submit_wait;
788

789 790 791 792 793 794 795 796 797 798 799
	/*
	 * 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;
800 801
	struct btrfs_super_block *super_copy;
	struct btrfs_super_block *super_for_commit;
C
Chris Mason 已提交
802
	struct super_block *sb;
803
	struct inode *btree_inode;
C
Chris Mason 已提交
804
	struct backing_dev_info bdi;
805
	struct mutex tree_log_mutex;
806 807
	struct mutex transaction_kthread_mutex;
	struct mutex cleaner_mutex;
808
	struct mutex chunk_mutex;
809
	struct mutex volume_mutex;
D
David Woodhouse 已提交
810

811 812 813 814 815 816
	/*
	 * 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 已提交
817 818 819 820 821 822
	/* 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;

823 824 825 826 827 828 829 830
	/*
	 * 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;
831

832
	struct rw_semaphore commit_root_sem;
833

834
	struct rw_semaphore cleanup_work_sem;
835

836
	struct rw_semaphore subvol_sem;
837 838
	struct srcu_struct subvol_srcu;

J
Josef Bacik 已提交
839
	spinlock_t trans_lock;
C
Chris Mason 已提交
840 841 842 843 844 845
	/*
	 * 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 已提交
846
	struct list_head trans_list;
847
	struct list_head dead_roots;
848
	struct list_head caching_block_groups;
849

Y
Yan, Zheng 已提交
850 851
	spinlock_t delayed_iput_lock;
	struct list_head delayed_iputs;
852
	struct mutex cleaner_delayed_iput_mutex;
Y
Yan, Zheng 已提交
853

J
Jan Schmidt 已提交
854 855
	/* this protects tree_mod_seq_list */
	spinlock_t tree_mod_seq_lock;
856
	atomic64_t tree_mod_seq;
J
Jan Schmidt 已提交
857 858 859 860 861 862
	struct list_head tree_mod_seq_list;

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

863
	atomic_t nr_async_submits;
864
	atomic_t async_submit_draining;
865
	atomic_t nr_async_bios;
866
	atomic_t async_delalloc_pages;
J
Josef Bacik 已提交
867
	atomic_t open_ioctl_trans;
868

869
	/*
870
	 * this is used to protect the following list -- ordered_roots.
871
	 */
872
	spinlock_t ordered_root_lock;
873 874

	/*
875 876 877
	 * all fs/file tree roots in which there are data=ordered extents
	 * pending writeback are added into this list.
	 *
878 879 880
	 * these can span multiple transactions and basically include
	 * every dirty data page that isn't from nodatacow
	 */
881
	struct list_head ordered_roots;
882

883
	struct mutex delalloc_root_mutex;
884 885 886
	spinlock_t delalloc_root_lock;
	/* all fs/file tree roots that have delalloc inodes. */
	struct list_head delalloc_roots;
887

888 889 890 891 892 893
	/*
	 * 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.
894 895 896
	 *
	 * A third pool does submit_bio to avoid deadlocking with the other
	 * two
897
	 */
898 899 900 901 902 903
	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;
904
	struct btrfs_workqueue *endio_repair_workers;
905 906 907 908 909 910 911
	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;
912

913 914 915 916 917
	/*
	 * 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
	 */
918 919
	struct btrfs_workqueue *fixup_workers;
	struct btrfs_workqueue *delayed_workers;
C
Chris Mason 已提交
920 921 922

	/* the extent workers do delayed refs on the extent allocation tree */
	struct btrfs_workqueue *extent_workers;
923 924
	struct task_struct *transaction_kthread;
	struct task_struct *cleaner_kthread;
925
	int thread_pool_size;
926

927
	struct kobject *space_info_kobj;
928

929
	u64 total_pinned;
930

931 932
	/* used to keep from writing metadata until there is a nice batch */
	struct percpu_counter dirty_metadata_bytes;
933
	struct percpu_counter delalloc_bytes;
934
	s32 dirty_metadata_batch;
935 936
	s32 delalloc_batch;

937 938
	struct list_head dirty_cowonly_roots;

939
	struct btrfs_fs_devices *fs_devices;
940 941 942 943 944 945

	/*
	 * 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.
	 */
946
	struct list_head space_info;
947

948 949
	struct btrfs_space_info *data_sinfo;

950 951
	struct reloc_control *reloc_ctl;

952 953 954 955 956
	/* 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 已提交
957

C
Chris Mason 已提交
958 959 960 961 962
	/* auto defrag inodes go here */
	spinlock_t defrag_inodes_lock;
	struct rb_root defrag_inodes;
	atomic_t defrag_running;

963 964
	/* Used to protect avail_{data, metadata, system}_alloc_bits */
	seqlock_t profiles_lock;
965 966 967 968 969
	/*
	 * 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 已提交
970 971 972
	u64 avail_data_alloc_bits;
	u64 avail_metadata_alloc_bits;
	u64 avail_system_alloc_bits;
973

974 975 976
	/* restriper state */
	spinlock_t balance_lock;
	struct mutex balance_mutex;
977 978
	atomic_t balance_running;
	atomic_t balance_pause_req;
979
	atomic_t balance_cancel_req;
980
	struct btrfs_balance_control *balance_ctl;
981
	wait_queue_head_t balance_wait_q;
982

983 984 985
	unsigned data_chunk_allocations;
	unsigned metadata_ratio;

986
	void *bdev_holder;
L
liubo 已提交
987

A
Arne Jansen 已提交
988 989 990 991 992 993 994 995
	/* 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;
996 997 998
	struct btrfs_workqueue *scrub_workers;
	struct btrfs_workqueue *scrub_wr_completion_workers;
	struct btrfs_workqueue *scrub_nocow_workers;
999
	struct btrfs_workqueue *scrub_parity_workers;
A
Arne Jansen 已提交
1000

1001 1002 1003
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	u32 check_integrity_print_mask;
#endif
1004 1005 1006 1007 1008
	/* 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 已提交
1009
	struct rb_root qgroup_op_tree;
1010
	spinlock_t qgroup_lock;
J
Josef Bacik 已提交
1011 1012
	spinlock_t qgroup_op_lock;
	atomic_t qgroup_op_seq;
1013

1014 1015 1016 1017 1018 1019
	/*
	 * used to avoid frequently calling ulist_alloc()/ulist_free()
	 * when doing qgroup accounting, it must be protected by qgroup_lock.
	 */
	struct ulist *qgroup_ulist;

1020 1021 1022
	/* protect user change for quota operations */
	struct mutex qgroup_ioctl_lock;

1023 1024 1025
	/* list of dirty qgroups to be written at next commit */
	struct list_head dirty_qgroups;

1026
	/* used by qgroup for an efficient tree traversal */
1027
	u64 qgroup_seq;
1028

J
Jan Schmidt 已提交
1029 1030 1031
	/* qgroup rescan items */
	struct mutex qgroup_rescan_lock; /* protects the progress item */
	struct btrfs_key qgroup_rescan_progress;
1032
	struct btrfs_workqueue *qgroup_rescan_workers;
1033
	struct completion qgroup_rescan_completion;
1034
	struct btrfs_work qgroup_rescan_work;
1035
	bool qgroup_rescan_running;	/* protected by qgroup_rescan_lock */
J
Jan Schmidt 已提交
1036

L
liubo 已提交
1037
	/* filesystem state */
1038
	unsigned long fs_state;
1039 1040

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

1042 1043 1044
	/* readahead tree */
	spinlock_t reada_lock;
	struct radix_tree_root reada_tree;
1045

Z
Zhao Lei 已提交
1046 1047 1048
	/* readahead works cnt */
	atomic_t reada_works_cnt;

1049 1050 1051 1052
	/* Extent buffer radix tree */
	spinlock_t buffer_lock;
	struct radix_tree_root buffer_radix;

C
Chris Mason 已提交
1053 1054
	/* next backup root to be overwritten */
	int backup_root_index;
1055 1056

	int num_tolerated_disk_barrier_failures;
1057 1058 1059

	/* device replace state */
	struct btrfs_dev_replace dev_replace;
1060 1061

	atomic_t mutually_exclusive_operation_running;
S
Stefan Behrens 已提交
1062

1063 1064 1065
	struct percpu_counter bio_counter;
	wait_queue_head_t replace_wait;

S
Stefan Behrens 已提交
1066
	struct semaphore uuid_tree_rescan_sem;
1067 1068 1069

	/* Used to reclaim the metadata space in the background. */
	struct work_struct async_reclaim_work;
1070 1071 1072

	spinlock_t unused_bgs_lock;
	struct list_head unused_bgs;
1073
	struct mutex unused_bg_unpin_mutex;
1074
	struct mutex delete_unused_bgs_mutex;
1075 1076 1077

	/* For btrfs to record security options */
	struct security_mnt_opts security_opts;
1078 1079 1080 1081 1082 1083

	/*
	 * 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;
1084

1085 1086
	/* Used to record internally whether fs has been frozen */
	int fs_frozen;
1087 1088 1089 1090 1091

	/* Cached block sizes */
	u32 nodesize;
	u32 sectorsize;
	u32 stripesize;
1092
};
1093

1094 1095 1096 1097 1098
static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
{
	return sb->s_fs_info;
}

1099 1100 1101 1102 1103
struct btrfs_subvolume_writers {
	struct percpu_counter	counter;
	wait_queue_head_t	wait;
};

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
/*
 * 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
1118 1119 1120 1121 1122
#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
1123

1124 1125
/*
 * in ram representation of the tree.  extent_root is used for all allocations
1126
 * and for the extent tree extent_root root.
1127 1128
 */
struct btrfs_root {
1129
	struct extent_buffer *node;
1130

1131
	struct extent_buffer *commit_root;
1132
	struct btrfs_root *log_root;
Z
Zheng Yan 已提交
1133
	struct btrfs_root *reloc_root;
Y
Yan Zheng 已提交
1134

1135
	unsigned long state;
1136 1137
	struct btrfs_root_item root_item;
	struct btrfs_key root_key;
1138
	struct btrfs_fs_info *fs_info;
1139 1140
	struct extent_io_tree dirty_log_pages;

1141
	struct mutex objectid_mutex;
Y
Yan Zheng 已提交
1142

1143 1144 1145
	spinlock_t accounting_lock;
	struct btrfs_block_rsv *block_rsv;

1146 1147
	/* free ino cache stuff */
	struct btrfs_free_space_ctl *free_ino_ctl;
1148 1149 1150
	enum btrfs_caching_type ino_cache_state;
	spinlock_t ino_cache_lock;
	wait_queue_head_t ino_cache_wait;
1151
	struct btrfs_free_space_ctl *free_ino_pinned;
1152 1153
	u64 ino_cache_progress;
	struct inode *ino_cache_inode;
1154

1155
	struct mutex log_mutex;
Y
Yan Zheng 已提交
1156 1157
	wait_queue_head_t log_writer_wait;
	wait_queue_head_t log_commit_wait[2];
1158
	struct list_head log_ctxs[2];
Y
Yan Zheng 已提交
1159 1160
	atomic_t log_writers;
	atomic_t log_commit[2];
M
Miao Xie 已提交
1161
	atomic_t log_batch;
1162
	int log_transid;
1163 1164 1165
	/* No matter the commit succeeds or not*/
	int log_transid_committed;
	/* Just be updated when the commit succeeds. */
1166
	int last_log_commit;
1167
	pid_t log_start_pid;
1168

1169 1170
	u64 objectid;
	u64 last_trans;
1171

1172
	u32 type;
1173 1174

	u64 highest_objectid;
C
Chris Mason 已提交
1175

1176
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1177
	/* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */
1178
	u64 alloc_bytenr;
1179
#endif
1180

1181
	u64 defrag_trans_start;
1182
	struct btrfs_key defrag_progress;
C
Chris Mason 已提交
1183
	struct btrfs_key defrag_max;
1184
	char *name;
1185 1186 1187

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

1189 1190
	struct list_head root_list;

1191 1192 1193
	spinlock_t log_extents_lock[2];
	struct list_head logged_list[2];

1194
	spinlock_t orphan_lock;
1195
	atomic_t orphan_inodes;
1196 1197
	struct btrfs_block_rsv *orphan_block_rsv;
	int orphan_cleanup_state;
1198

1199 1200 1201 1202
	spinlock_t inode_lock;
	/* red-black tree that keeps track of in-memory inodes */
	struct rb_root inode_tree;

1203 1204 1205 1206 1207
	/*
	 * radix tree that keeps track of delayed nodes of every inode,
	 * protected by inode_lock
	 */
	struct radix_tree_root delayed_nodes_tree;
1208 1209 1210 1211
	/*
	 * right now this just gets used so that a root has its own devid
	 * for stat.  It may be used for more later
	 */
1212
	dev_t anon_dev;
1213

1214
	spinlock_t root_item_lock;
1215
	atomic_t refs;
1216

1217
	struct mutex delalloc_mutex;
1218 1219 1220 1221 1222 1223 1224 1225 1226
	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;
1227 1228

	struct mutex ordered_extent_mutex;
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
	/*
	 * 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;
1243 1244 1245 1246 1247 1248

	/*
	 * Number of currently running SEND ioctls to prevent
	 * manipulation with the read-only status via SUBVOL_SETFLAGS
	 */
	int send_in_progress;
1249 1250
	struct btrfs_subvolume_writers *subv_writers;
	atomic_t will_be_snapshoted;
1251 1252 1253

	/* For qgroup metadata space reserve */
	atomic_t qgroup_meta_rsv;
1254
};
1255 1256 1257 1258
static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
{
	return btrfs_sb(inode->i_sb)->sectorsize;
}
1259

1260 1261 1262 1263 1264
static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 blocksize)
{
	return blocksize - sizeof(struct btrfs_header);
}

1265
static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1266
{
1267
	return __BTRFS_LEAF_DATA_SIZE(info->nodesize);
1268 1269
}

1270
static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
1271
{
1272
	return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
1273 1274
}

1275
static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
1276
{
1277
	return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
1278 1279 1280 1281
}

#define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
		(offsetof(struct btrfs_file_extent_item, disk_bytenr))
1282
static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
1283
{
1284
	return BTRFS_MAX_ITEM_SIZE(info) -
1285 1286 1287
	       BTRFS_FILE_EXTENT_INLINE_DATA_START;
}

1288
static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
1289
{
1290
	return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
1291 1292
}

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

1327
#define BTRFS_DEFAULT_COMMIT_INTERVAL	(30)
1328
#define BTRFS_DEFAULT_MAX_INLINE	(2048)
1329

1330 1331
#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)
#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)
M
Miao Xie 已提交
1332
#define btrfs_raw_test_opt(o, opt)	((o) & BTRFS_MOUNT_##opt)
1333
#define btrfs_test_opt(fs_info, opt)	((fs_info)->mount_opt & \
1334
					 BTRFS_MOUNT_##opt)
1335

1336
#define btrfs_set_and_info(fs_info, opt, fmt, args...)			\
1337
{									\
1338 1339 1340
	if (!btrfs_test_opt(fs_info, opt))				\
		btrfs_info(fs_info, fmt, ##args);			\
	btrfs_set_opt(fs_info->mount_opt, opt);				\
1341 1342
}

1343
#define btrfs_clear_and_info(fs_info, opt, fmt, args...)		\
1344
{									\
1345 1346 1347
	if (btrfs_test_opt(fs_info, opt))				\
		btrfs_info(fs_info, fmt, ##args);			\
	btrfs_clear_opt(fs_info->mount_opt, opt);			\
1348 1349
}

1350 1351 1352 1353 1354
#ifdef CONFIG_BTRFS_DEBUG
static inline int
btrfs_should_fragment_free_space(struct btrfs_root *root,
				 struct btrfs_block_group_cache *block_group)
{
1355
	return (btrfs_test_opt(root->fs_info, FRAGMENT_METADATA) &&
1356
		block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
1357
	       (btrfs_test_opt(root->fs_info, FRAGMENT_DATA) &&
1358 1359 1360 1361
		block_group->flags &  BTRFS_BLOCK_GROUP_DATA);
}
#endif

1362 1363 1364 1365 1366 1367 1368 1369
/*
 * 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)
 */

1370 1371
#define BTRFS_PENDING_SET_INODE_MAP_CACHE	(0)
#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE	(1)
1372
#define BTRFS_PENDING_COMMIT			(2)
1373

1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
#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 已提交
1405 1406 1407
/*
 * Inode flags
 */
Y
Yan 已提交
1408 1409 1410
#define BTRFS_INODE_NODATASUM		(1 << 0)
#define BTRFS_INODE_NODATACOW		(1 << 1)
#define BTRFS_INODE_READONLY		(1 << 2)
C
Chris Mason 已提交
1411
#define BTRFS_INODE_NOCOMPRESS		(1 << 3)
Y
Yan Zheng 已提交
1412
#define BTRFS_INODE_PREALLOC		(1 << 4)
1413 1414 1415 1416 1417 1418
#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)
1419
#define BTRFS_INODE_COMPRESS		(1 << 11)
1420

1421 1422
#define BTRFS_INODE_ROOT_ITEM_INIT	(1 << 31)

1423 1424 1425 1426 1427 1428
struct btrfs_map_token {
	struct extent_buffer *eb;
	char *kaddr;
	unsigned long offset;
};

1429 1430 1431
#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
				((bytes) >> (fs_info)->sb->s_blocksize_bits)

1432 1433
static inline void btrfs_init_map_token (struct btrfs_map_token *token)
{
J
Josef Bacik 已提交
1434
	token->kaddr = NULL;
1435 1436
}

1437
/* some macros to generate set/get functions for the struct fields.  This
1438 1439 1440 1441 1442 1443 1444
 * 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

1445
#define read_eb_member(eb, ptr, type, member, result) (\
1446 1447 1448 1449 1450
	read_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

1451
#define write_eb_member(eb, ptr, type, member, result) (\
1452 1453 1454 1455 1456
	write_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

L
Li Zefan 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
#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)

1480
#define BTRFS_SETGET_FUNCS(name, type, member, bits)			\
L
Li Zefan 已提交
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
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); \
}
1505 1506 1507 1508

#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)		\
static inline u##bits btrfs_##name(struct extent_buffer *eb)		\
{									\
1509
	type *p = page_address(eb->pages[0]);				\
D
David Miller 已提交
1510
	u##bits res = le##bits##_to_cpu(p->member);			\
1511
	return res;							\
1512 1513 1514 1515
}									\
static inline void btrfs_set_##name(struct extent_buffer *eb,		\
				    u##bits val)			\
{									\
1516
	type *p = page_address(eb->pages[0]);				\
D
David Miller 已提交
1517
	p->member = cpu_to_le##bits(val);				\
1518
}
C
Chris Mason 已提交
1519

1520 1521 1522 1523 1524 1525 1526 1527
#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 已提交
1528 1529
}

1530 1531 1532 1533 1534
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);
1535 1536
BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
		   start_offset, 64);
1537 1538
BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1539 1540 1541
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 已提交
1542
BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1543

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
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);
1556 1557 1558 1559 1560 1561
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 已提交
1562 1563
BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
			 generation, 64);
1564

1565
static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
1566
{
1567
	return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
1568 1569
}

1570
static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
Y
Yan Zheng 已提交
1571
{
1572
	return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
Y
Yan Zheng 已提交
1573 1574
}

1575
BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1576 1577 1578 1579 1580 1581 1582
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 已提交
1583
BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1584 1585 1586
BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);

1587 1588 1589 1590 1591 1592
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);
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
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 已提交
1605 1606
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
			 sub_stripes, 16);
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
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;
}

1619 1620 1621 1622 1623
static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
{
	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
}

1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
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));
}

1636 1637 1638 1639 1640
/* 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);
1641 1642
BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
			struct btrfs_block_group_item, chunk_objectid, 64);
1643 1644

BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
1645 1646 1647 1648 1649
		   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 已提交
1650

1651 1652 1653 1654 1655
/* 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);

1656 1657
/* struct btrfs_inode_ref */
BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1658
BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1659

M
Mark Fasheh 已提交
1660 1661 1662 1663 1664 1665 1666
/* 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);

1667 1668
/* struct btrfs_inode_item */
BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1669
BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1670
BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1671
BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1672
BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1673 1674 1675 1676 1677
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);
1678
BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1679
BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696
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);
1697 1698
BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1699 1700
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 已提交
1701

1702
/* struct btrfs_dev_extent */
1703 1704 1705 1706 1707 1708
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);
1709 1710
BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);

1711
static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1712 1713
{
	unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1714
	return (unsigned long)dev + ptr;
1715 1716
}

1717 1718 1719 1720
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);
1721

1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
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 已提交
1740

1741 1742 1743 1744 1745 1746 1747 1748 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
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 已提交
1778

1779 1780
/* struct btrfs_node */
BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1781
BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1782 1783 1784 1785
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 已提交
1786

1787
static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1788
{
1789 1790 1791 1792
	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 已提交
1793 1794
}

1795 1796
static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
					   int nr, u64 val)
C
Chris Mason 已提交
1797
{
1798 1799 1800 1801
	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 已提交
1802 1803
}

1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
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);
}

1821
static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1822
{
1823 1824
	return offsetof(struct btrfs_node, ptrs) +
		sizeof(struct btrfs_key_ptr) * nr;
1825 1826
}

1827 1828 1829
void btrfs_node_key(struct extent_buffer *eb,
		    struct btrfs_disk_key *disk_key, int nr);

1830 1831
static inline void btrfs_set_node_key(struct extent_buffer *eb,
				      struct btrfs_disk_key *disk_key, int nr)
1832
{
1833 1834 1835 1836
	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);
1837 1838
}

1839 1840 1841
/* struct btrfs_item */
BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1842 1843
BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
1844

1845
static inline unsigned long btrfs_item_nr_offset(int nr)
1846
{
1847 1848
	return offsetof(struct btrfs_leaf, items) +
		sizeof(struct btrfs_item) * nr;
1849 1850
}

1851
static inline struct btrfs_item *btrfs_item_nr(int nr)
C
Chris Mason 已提交
1852
{
1853
	return (struct btrfs_item *)btrfs_item_nr_offset(nr);
C
Chris Mason 已提交
1854 1855
}

1856 1857
static inline u32 btrfs_item_end(struct extent_buffer *eb,
				 struct btrfs_item *item)
C
Chris Mason 已提交
1858
{
1859
	return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
C
Chris Mason 已提交
1860 1861
}

1862
static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1863
{
1864
	return btrfs_item_end(eb, btrfs_item_nr(nr));
C
Chris Mason 已提交
1865 1866
}

1867
static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
C
Chris Mason 已提交
1868
{
1869
	return btrfs_item_offset(eb, btrfs_item_nr(nr));
C
Chris Mason 已提交
1870 1871
}

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

1877 1878
static inline void btrfs_item_key(struct extent_buffer *eb,
			   struct btrfs_disk_key *disk_key, int nr)
1879
{
1880
	struct btrfs_item *item = btrfs_item_nr(nr);
1881
	read_eb_member(eb, item, struct btrfs_item, key, disk_key);
1882 1883
}

1884 1885
static inline void btrfs_set_item_key(struct extent_buffer *eb,
			       struct btrfs_disk_key *disk_key, int nr)
1886
{
1887
	struct btrfs_item *item = btrfs_item_nr(nr);
1888
	write_eb_member(eb, item, struct btrfs_item, key, disk_key);
1889 1890
}

1891 1892
BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);

1893 1894 1895 1896 1897 1898 1899
/*
 * 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);

1900
/* struct btrfs_dir_item */
J
Josef Bacik 已提交
1901
BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
1902 1903
BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
1904
BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
1905 1906 1907 1908 1909 1910 1911
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);
1912

1913 1914 1915
static inline void btrfs_dir_item_key(struct extent_buffer *eb,
				      struct btrfs_dir_item *item,
				      struct btrfs_disk_key *key)
1916
{
1917
	read_eb_member(eb, item, struct btrfs_dir_item, location, key);
1918 1919
}

1920 1921 1922
static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
					  struct btrfs_dir_item *item,
					  struct btrfs_disk_key *key)
1923
{
1924
	write_eb_member(eb, item, struct btrfs_dir_item, location, key);
1925 1926
}

1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
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);
}

1948 1949 1950 1951 1952
/* 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);
1953

C
Chris Mason 已提交
1954 1955 1956 1957
static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
					 struct btrfs_disk_key *disk)
{
	cpu->offset = le64_to_cpu(disk->offset);
1958
	cpu->type = disk->type;
C
Chris Mason 已提交
1959 1960 1961 1962 1963 1964 1965
	cpu->objectid = le64_to_cpu(disk->objectid);
}

static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
					 struct btrfs_key *cpu)
{
	disk->offset = cpu_to_le64(cpu->offset);
1966
	disk->type = cpu->type;
C
Chris Mason 已提交
1967 1968 1969
	disk->objectid = cpu_to_le64(cpu->objectid);
}

1970 1971
static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
				  struct btrfs_key *key, int nr)
1972
{
1973 1974 1975
	struct btrfs_disk_key disk_key;
	btrfs_node_key(eb, &disk_key, nr);
	btrfs_disk_key_to_cpu(key, &disk_key);
1976 1977
}

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

1986 1987 1988
static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
				      struct btrfs_dir_item *item,
				      struct btrfs_key *key)
1989
{
1990 1991 1992
	struct btrfs_disk_key disk_key;
	btrfs_dir_item_key(eb, item, &disk_key);
	btrfs_disk_key_to_cpu(key, &disk_key);
1993 1994
}

1995

1996
static inline u8 btrfs_key_type(struct btrfs_key *key)
1997
{
1998
	return key->type;
1999 2000
}

2001
static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2002
{
2003
	key->type = val;
2004 2005
}

2006
/* struct btrfs_header */
2007
BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2008 2009 2010 2011
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);
2012
BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2013
BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2014 2015 2016 2017 2018 2019
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);
2020

2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
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;
}

2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
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);
}

2055
static inline unsigned long btrfs_header_fsid(void)
2056
{
2057
	return offsetof(struct btrfs_header, fsid);
2058 2059
}

2060
static inline unsigned long btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
2061
{
2062
	return offsetof(struct btrfs_header, chunk_tree_uuid);
2063 2064
}

2065
static inline int btrfs_is_leaf(struct extent_buffer *eb)
2066
{
C
Chris Mason 已提交
2067
	return btrfs_header_level(eb) == 0;
2068 2069
}

2070
/* struct btrfs_root_item */
2071 2072
BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
		   generation, 64);
2073
BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2074 2075
BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2076

2077 2078
BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
			 generation, 64);
2079 2080
BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2081 2082
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);
2083
BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2084 2085
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 已提交
2086 2087
BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
			 last_snapshot, 64);
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
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 已提交
2098

L
Li Zefan 已提交
2099 2100
static inline bool btrfs_root_readonly(struct btrfs_root *root)
{
2101
	return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
L
Li Zefan 已提交
2102 2103
}

2104 2105 2106 2107 2108
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 已提交
2109 2110 2111 2112 2113 2114 2115 2116 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
/* 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);

2158 2159
/* struct btrfs_balance_item */
BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2160

2161 2162 2163 2164 2165 2166 2167 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
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);
2218
	cpu->limit = le64_to_cpu(disk->limit);
2219 2220
	cpu->stripes_min = le32_to_cpu(disk->stripes_min);
	cpu->stripes_max = le32_to_cpu(disk->stripes_max);
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237
}

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);
2238
	disk->limit = cpu_to_le64(cpu->limit);
2239 2240
	disk->stripes_min = cpu_to_le32(cpu->stripes_min);
	disk->stripes_max = cpu_to_le32(cpu->stripes_max);
2241 2242 2243
}

/* struct btrfs_super_block */
2244
BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2245
BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2246 2247 2248
BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
			 generation, 64);
BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2249 2250
BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
			 struct btrfs_super_block, sys_chunk_array_size, 32);
2251 2252
BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
			 struct btrfs_super_block, chunk_root_generation, 64);
2253 2254
BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
			 root_level, 8);
2255 2256 2257
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,
2258 2259 2260
			 chunk_root_level, 8);
BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
			 log_root, 64);
2261 2262
BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
			 log_root_transid, 64);
2263 2264
BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
			 log_root_level, 8);
2265 2266 2267 2268
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);
2269 2270 2271 2272
BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
			 sectorsize, 32);
BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
			 nodesize, 32);
2273 2274
BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
			 stripesize, 32);
2275 2276
BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
			 root_dir_objectid, 64);
2277 2278
BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
			 num_devices, 64);
2279 2280 2281
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,
2282
			 compat_ro_flags, 64);
2283 2284
BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
			 incompat_flags, 64);
2285 2286
BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
			 csum_type, 16);
2287 2288
BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
			 cache_generation, 64);
2289
BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
2290 2291
BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
			 uuid_tree_generation, 64);
2292 2293 2294

static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
{
D
David Sterba 已提交
2295 2296 2297 2298
	u16 t = btrfs_super_csum_type(s);
	/*
	 * csum type is validated at mount time
	 */
2299 2300
	return btrfs_csum_sizes[t];
}
2301

2302
static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
2303
{
2304
	return offsetof(struct btrfs_leaf, items);
2305 2306
}

2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
/*
 * 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
 */
static inline unsigned int leaf_data_end(struct btrfs_root *root,
					 struct extent_buffer *leaf)
{
	u32 nr = btrfs_header_nritems(leaf);

	if (nr == 0)
2318
		return BTRFS_LEAF_DATA_SIZE(root->fs_info);
2319 2320 2321
	return btrfs_item_offset_nr(leaf, nr - 1);
}

2322 2323
/* struct btrfs_file_extent_item */
BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2324 2325 2326 2327 2328 2329 2330 2331
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);
2332 2333 2334 2335
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);
2336

C
Chris Mason 已提交
2337 2338
static inline unsigned long
btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
2339
{
2340
	return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
2341 2342 2343 2344
}

static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
{
2345
	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2346 2347
}

2348 2349
BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
		   disk_bytenr, 64);
2350 2351
BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
		   generation, 64);
2352 2353
BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
		   disk_num_bytes, 64);
2354 2355
BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
		  offset, 64);
2356 2357
BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
		   num_bytes, 64);
C
Chris Mason 已提交
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
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)
{
2375
	return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
C
Chris Mason 已提交
2376
}
2377

2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
/* 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);
}


2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
/* 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 已提交
2428 2429 2430 2431 2432 2433 2434
/* 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 已提交
2435 2436
BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
		   rescan, 64);
A
Arne Jansen 已提交
2437 2438 2439 2440 2441 2442 2443 2444 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

/* 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);

2471 2472 2473 2474 2475 2476 2477 2478 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
/* 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);

2514 2515
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
C
Chris Mason 已提交
2516
	((type *)(btrfs_leaf_data(leaf) + \
2517 2518 2519 2520 2521
	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)))
2522

2523 2524 2525 2526 2527 2528
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));
}

2529 2530
static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
{
2531
	return mapping_gfp_constraint(mapping, ~__GFP_FS);
2532 2533
}

C
Chris Mason 已提交
2534
/* extent-tree.c */
2535 2536 2537

u64 btrfs_csum_bytes_to_leaves(struct btrfs_root *root, u64 csum_bytes);

2538
static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
2539
						 unsigned num_items)
2540
{
2541
	return root->fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2542 2543 2544 2545 2546 2547 2548 2549 2550
}

/*
 * Doing a truncate won't result in new nodes or leaves, just what we need for
 * COW.
 */
static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
						 unsigned num_items)
{
2551
	return root->fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2552 2553
}

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

2622 2623
int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len,
			       int delalloc);
2624 2625
int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
				       u64 start, u64 len);
2626 2627
void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root);
C
Chris Mason 已提交
2628
int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
2629
			       struct btrfs_root *root);
C
Chris Mason 已提交
2630
int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Z
Zheng Yan 已提交
2631 2632
			 struct btrfs_root *root,
			 u64 bytenr, u64 num_bytes, u64 parent,
2633
			 u64 root_objectid, u64 owner, u64 offset);
2634

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

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,
};

2674 2675 2676 2677 2678 2679 2680 2681 2682
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,
};

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

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

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

2836 2837 2838 2839 2840 2841 2842 2843 2844
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);
}

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

static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path,
					  struct btrfs_key *key,
					  u32 data_size)
{
	return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
}

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

/*
 * 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.
 */
static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root)
{
	return (root->fs_info->sb->s_flags & MS_RDONLY ||
		btrfs_fs_closing(root->fs_info));
}

2912 2913
static inline void free_fs_info(struct btrfs_fs_info *fs_info)
{
2914
	kfree(fs_info->balance_ctl);
2915 2916 2917 2918 2919 2920
	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);
2921
	kfree(fs_info->quota_root);
2922
	kfree(fs_info->uuid_root);
2923
	kfree(fs_info->free_space_root);
2924 2925
	kfree(fs_info->super_copy);
	kfree(fs_info->super_for_commit);
2926
	security_free_mnt_opts(&fs_info->security_opts);
2927 2928
	kfree(fs_info);
}
2929

2930 2931 2932 2933 2934
/* 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 已提交
2935
int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
2936

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

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

C
Chris Mason 已提交
2976
/* dir-item.c */
C
Chris Mason 已提交
2977 2978
int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
			  const char *name, int name_len);
C
Chris Mason 已提交
2979 2980
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, const char *name,
2981
			  int name_len, struct inode *dir,
2982
			  struct btrfs_key *location, u8 type, u64 index);
2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993
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);
2994 2995 2996 2997
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);
2998 2999 3000 3001
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 已提交
3002
int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3003 3004 3005 3006
			    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 已提交
3007 3008 3009 3010 3011
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);
3012 3013 3014
int verify_dir_item(struct btrfs_root *root,
		    struct extent_buffer *leaf,
		    struct btrfs_dir_item *dir_item);
3015 3016 3017 3018
struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
						 struct btrfs_path *path,
						 const char *name,
						 int name_len);
3019 3020 3021 3022 3023 3024

/* 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);
3025
int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3026

C
Chris Mason 已提交
3027
/* inode-item.c */
3028 3029 3030
int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root,
			   const char *name, int name_len,
3031
			   u64 inode_objectid, u64 ref_objectid, u64 index);
3032 3033 3034
int btrfs_del_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_insert_empty_inode(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid);
3039
int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
3040 3041
		       *root, struct btrfs_path *path,
		       struct btrfs_key *location, int mod);
C
Chris Mason 已提交
3042

M
Mark Fasheh 已提交
3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
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 已提交
3056
/* file-item.c */
3057
struct btrfs_dio_private;
3058
int btrfs_del_csums(struct btrfs_trans_handle *trans,
3059
		    struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
3060
int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
3061
			  struct bio *bio, u32 *dst);
3062
int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
3063
			      struct bio *bio, u64 logical_offset);
C
Chris Mason 已提交
3064
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
3065 3066 3067 3068 3069
			     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 已提交
3070 3071 3072
int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid,
3073
			     u64 bytenr, int mod);
3074
int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3075
			   struct btrfs_root *root,
3076
			   struct btrfs_ordered_sum *sums);
3077
int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
3078
		       struct bio *bio, u64 file_start, int contig);
A
Arne Jansen 已提交
3079 3080
int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
			     struct list_head *list, int search_commit);
3081 3082 3083 3084 3085 3086
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 已提交
3087
/* inode.c */
3088 3089 3090 3091 3092 3093 3094 3095 3096
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,
3097
						    int delay_iput);
3098 3099
void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);

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

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

L
Li Zefan 已提交
3114 3115 3116 3117 3118 3119 3120 3121
/* 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);
}

3122 3123
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
int btrfs_set_inode_index(struct inode *dir, u64 *index);
3124 3125 3126 3127 3128 3129 3130
int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root,
		       struct inode *dir, struct inode *inode,
		       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);
3131 3132 3133 3134
int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
			struct btrfs_root *root,
			struct inode *dir, u64 objectid,
			const char *name, int name_len);
3135
int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
J
Josef Bacik 已提交
3136
			int front);
3137 3138 3139 3140 3141
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 已提交
3142
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
3143 3144
int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput,
			       int nr);
3145
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3146
			      struct extent_state **cached_state, int dedupe);
3147
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3148 3149 3150
			     struct btrfs_root *new_root,
			     struct btrfs_root *parent_root,
			     u64 new_dirid);
3151
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
3152 3153
			 size_t size, struct bio *bio,
			 unsigned long bio_flags);
3154
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
C
Chris Mason 已提交
3155
int btrfs_readpage(struct file *file, struct page *page);
A
Al Viro 已提交
3156
void btrfs_evict_inode(struct inode *inode);
3157
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
C
Chris Mason 已提交
3158 3159
struct inode *btrfs_alloc_inode(struct super_block *sb);
void btrfs_destroy_inode(struct inode *inode);
3160
int btrfs_drop_inode(struct inode *inode);
C
Chris Mason 已提交
3161 3162
int btrfs_init_cachep(void);
void btrfs_destroy_cachep(void);
S
Sage Weil 已提交
3163
long btrfs_ioctl_trans_end(struct file *file);
B
Balaji Rao 已提交
3164
struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3165
			 struct btrfs_root *root, int *was_new);
3166
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3167
				    size_t pg_offset, u64 start, u64 end,
3168 3169 3170 3171
				    int create);
int btrfs_update_inode(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct inode *inode);
3172 3173
int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode);
3174
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
3175
int btrfs_orphan_cleanup(struct btrfs_root *root);
3176 3177
void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root);
3178
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3179
void btrfs_invalidate_inodes(struct btrfs_root *root);
Y
Yan, Zheng 已提交
3180 3181
void btrfs_add_delayed_iput(struct inode *inode);
void btrfs_run_delayed_iputs(struct btrfs_root *root);
3182 3183 3184
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);
3185 3186 3187 3188
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);
3189
extern const struct dentry_operations btrfs_dentry_operations;
3190 3191 3192
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
void btrfs_test_inode_set_ops(struct inode *inode);
#endif
C
Christoph Hellwig 已提交
3193 3194 3195

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

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

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

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

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

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

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

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

3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290
#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)
3291

3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309
/*
 * 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)

3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327
/*
 * 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)

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344
/*
 * 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 已提交
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 3373

#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)
3374 3375
#define btrfs_debug(fs_info, fmt, args...) \
	btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3376 3377
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3378 3379
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
	btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3380 3381
#define btrfs_debug_rl(fs_info, fmt, args...) \
	btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
3382 3383
#else
#define btrfs_debug(fs_info, fmt, args...) \
3384
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3385
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3386
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3387
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3388
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3389
#define btrfs_debug_rl(fs_info, fmt, args...) \
3390
	btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3391
#endif
3392

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

3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
#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 已提交
3416 3417
#ifdef CONFIG_BTRFS_ASSERT

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

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

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

3437
const char *btrfs_decode_error(int errno);
3438

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

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

3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495
#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)) {
3496 3497 3498 3499 3500
		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);
3501
			btrfs_info(fs_info, "setting %llu feature flag",
3502 3503 3504
					 flag);
		}
		spin_unlock(&fs_info->super_lock);
3505 3506 3507
	}
}

3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
#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);
	}
}

3532 3533 3534
#define btrfs_fs_incompat(fs_info, opt) \
	__btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)

3535
static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3536 3537 3538 3539 3540 3541
{
	struct btrfs_super_block *disk_super;
	disk_super = fs_info->super_copy;
	return !!(btrfs_super_incompat_flags(disk_super) & flag);
}

3542 3543 3544 3545 3546 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
#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 已提交
3600
/* acl.c */
C
Chris Mason 已提交
3601
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
3602
struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3603
int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
3604 3605
int btrfs_init_acl(struct btrfs_trans_handle *trans,
		   struct inode *inode, struct inode *dir);
3606
#else
3607
#define btrfs_get_acl NULL
3608
#define btrfs_set_acl NULL
3609 3610 3611 3612 3613 3614
static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
				 struct inode *inode, struct inode *dir)
{
	return 0;
}
#endif
J
Josef Bacik 已提交
3615

3616
/* relocation.c */
3617
int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
3618 3619 3620 3621 3622 3623
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);
3624 3625 3626
int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, struct extent_buffer *buf,
			  struct extent_buffer *cow);
3627
void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
3628
			      u64 *bytes_to_reserve);
3629
int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3630
			      struct btrfs_pending_snapshot *pending);
A
Arne Jansen 已提交
3631 3632

/* scrub.c */
3633 3634
int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
		    u64 end, struct btrfs_scrub_progress *progress,
3635
		    int readonly, int is_dev_replace);
3636 3637
void btrfs_scrub_pause(struct btrfs_root *root);
void btrfs_scrub_continue(struct btrfs_root *root);
3638 3639 3640
int btrfs_scrub_cancel(struct btrfs_fs_info *info);
int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
			   struct btrfs_device *dev);
A
Arne Jansen 已提交
3641 3642
int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
			 struct btrfs_scrub_progress *progress);
3643 3644 3645 3646

/* 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);
3647 3648 3649 3650 3651 3652
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 已提交
3653

3654 3655
/* reada.c */
struct reada_control {
3656
	struct btrfs_fs_info	*fs_info;		/* tree to prefetch */
3657 3658 3659 3660 3661 3662 3663 3664 3665 3666
	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);
3667
int btree_readahead_hook(struct btrfs_fs_info *fs_info,
3668
			 struct extent_buffer *eb, int err);
3669

3670 3671 3672
static inline int is_fstree(u64 rootid)
{
	if (rootid == BTRFS_FS_TREE_OBJECTID ||
3673 3674
	    ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
	      !btrfs_qgroup_level(rootid)))
3675 3676 3677
		return 1;
	return 0;
}
3678 3679 3680 3681 3682 3683

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

3684 3685 3686 3687
/* Sanity test specific functions */
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
void btrfs_test_destroy_inode(struct inode *inode);
#endif
3688

3689
static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3690 3691
{
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3692 3693
	if (unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO,
			      &fs_info->fs_state)))
3694 3695 3696 3697
		return 1;
#endif
	return 0;
}
3698
#endif