ctree.h 59.6 KB
Newer Older
Chris Mason's avatar
Chris Mason committed
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.
 */

Chris Mason's avatar
Chris Mason committed
19
20
#ifndef __BTRFS_CTREE__
#define __BTRFS_CTREE__
21

22
#include <linux/version.h>
23
24
#include <linux/mm.h>
#include <linux/highmem.h>
Chris Mason's avatar
Chris Mason committed
25
#include <linux/fs.h>
26
#include <linux/completion.h>
Chris Mason's avatar
Chris Mason committed
27
#include <linux/backing-dev.h>
28
#include <linux/wait.h>
29
#include <asm/kmap_types.h>
Chris Mason's avatar
Chris Mason committed
30
#include "bit-radix.h"
31
#include "extent_io.h"
32
#include "extent_map.h"
33
#include "async-thread.h"
Chris Mason's avatar
Chris Mason committed
34

35
struct btrfs_trans_handle;
Chris Mason's avatar
Chris Mason committed
36
struct btrfs_transaction;
37
38
39
extern struct kmem_cache *btrfs_trans_handle_cachep;
extern struct kmem_cache *btrfs_transaction_cachep;
extern struct kmem_cache *btrfs_bit_radix_cachep;
Chris Mason's avatar
Chris Mason committed
40
extern struct kmem_cache *btrfs_path_cachep;
41
struct btrfs_ordered_sum;
42

Zheng Yan's avatar
Zheng Yan committed
43
#define BTRFS_MAGIC "_B9RfS_M"
44

Josef Bacik's avatar
Josef Bacik committed
45
46
#define BTRFS_ACL_NOT_CACHED    ((void *)-1)

47
48
49
50
51
#ifdef CONFIG_LOCKDEP
# define BTRFS_MAX_LEVEL 7
#else
# define BTRFS_MAX_LEVEL 8
#endif
52
53

/* holds pointers to all of the tree roots */
54
#define BTRFS_ROOT_TREE_OBJECTID 1ULL
55
56

/* stores information about which extents are in use, and reference counts */
Chris Mason's avatar
Chris Mason committed
57
#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
58
59
60
61
62

/*
 * chunk tree stores translations from logical -> physical block numbering
 * the super block points to the chunk tree
 */
63
#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
64
65
66
67
68

/*
 * stores information about which areas of a given device are in use.
 * one per device.  The tree of tree roots points to the device tree
 */
69
70
71
72
73
74
75
#define BTRFS_DEV_TREE_OBJECTID 4ULL

/* one per subvolume, storing files and directories */
#define BTRFS_FS_TREE_OBJECTID 5ULL

/* directory objectid inside the root tree */
#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
76

77
78
79
/* orhpan objectid for tracking unlinked/truncated files */
#define BTRFS_ORPHAN_OBJECTID -5ULL

80
81
82
83
/* does write ahead logging to speed up fsyncs */
#define BTRFS_TREE_LOG_OBJECTID -6ULL
#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL

Zheng Yan's avatar
Zheng Yan committed
84
85
86
/* dummy objectid represents multiple objectids */
#define BTRFS_MULTIPLE_OBJECTIDS -255ULL

87
/*
88
 * All files have objectids in this range.
89
 */
90
#define BTRFS_FIRST_FREE_OBJECTID 256ULL
91
#define BTRFS_LAST_FREE_OBJECTID -256ULL
92
#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
93

94
95
96
97
98
99
100

/*
 * the device items go into the chunk tree.  The key is in the form
 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
 */
#define BTRFS_DEV_ITEMS_OBJECTID 1ULL

Chris Mason's avatar
Chris Mason committed
101
102
103
104
105
106
/*
 * we can actually store much bigger names, but lets not confuse the rest
 * of linux
 */
#define BTRFS_NAME_LEN 255

Chris Mason's avatar
Chris Mason committed
107
108
/* 32 bytes in various csum fields */
#define BTRFS_CSUM_SIZE 32
109
110
/* four bytes for CRC32 */
#define BTRFS_CRC32_SIZE 4
111
#define BTRFS_EMPTY_DIR_SIZE 0
Chris Mason's avatar
Chris Mason committed
112

Chris Mason's avatar
Chris Mason committed
113
114
115
116
117
118
119
120
#define BTRFS_FT_UNKNOWN	0
#define BTRFS_FT_REG_FILE	1
#define BTRFS_FT_DIR		2
#define BTRFS_FT_CHRDEV		3
#define BTRFS_FT_BLKDEV		4
#define BTRFS_FT_FIFO		5
#define BTRFS_FT_SOCK		6
#define BTRFS_FT_SYMLINK	7
Josef Bacik's avatar
Josef Bacik committed
121
122
#define BTRFS_FT_XATTR		8
#define BTRFS_FT_MAX		9
Chris Mason's avatar
Chris Mason committed
123

124
125
126
127
128
129
130
131
132
/*
 * the key defines the order in the tree, and so it also defines (optimal)
 * block layout.  objectid corresonds to the inode number.  The flags
 * tells us things about the object, and is a kind of stream selector.
 * so for a given inode, keys with flags of 1 might refer to the inode
 * data, flags of 2 may point to file data in the btree and flags == 3
 * may point to extents.
 *
 * offset is the starting byte offset for this key in the stream.
Chris Mason's avatar
Chris Mason committed
133
134
135
136
 *
 * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
 * in cpu native order.  Otherwise they are identical and their sizes
 * should be the same (ie both packed)
137
 */
Chris Mason's avatar
Chris Mason committed
138
139
struct btrfs_disk_key {
	__le64 objectid;
140
	u8 type;
141
	__le64 offset;
Chris Mason's avatar
Chris Mason committed
142
143
144
} __attribute__ ((__packed__));

struct btrfs_key {
145
	u64 objectid;
146
	u8 type;
147
	u64 offset;
148
149
} __attribute__ ((__packed__));

150
151
152
153
struct btrfs_mapping_tree {
	struct extent_map_tree map_tree;
};

154
#define BTRFS_UUID_SIZE 16
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
struct btrfs_dev_item {
	/* the internal btrfs device id */
	__le64 devid;

	/* size of the device */
	__le64 total_bytes;

	/* bytes used */
	__le64 bytes_used;

	/* optimal io alignment for this device */
	__le32 io_align;

	/* optimal io width for this device */
	__le32 io_width;

	/* minimal io size for this device */
	__le32 sector_size;

	/* type and info about this device */
	__le64 type;

177
178
179
180
181
182
183
184
185
	/* grouping information for allocation decisions */
	__le32 dev_group;

	/* seek speed 0-100 where 100 is fastest */
	u8 seek_speed;

	/* bandwidth 0-100 where 100 is fastest */
	u8 bandwidth;

186
	/* btrfs generated uuid for this device */
187
	u8 uuid[BTRFS_UUID_SIZE];
188
189
190
191
192
} __attribute__ ((__packed__));

struct btrfs_stripe {
	__le64 devid;
	__le64 offset;
193
	u8 dev_uuid[BTRFS_UUID_SIZE];
194
195
196
} __attribute__ ((__packed__));

struct btrfs_chunk {
197
198
199
200
	/* size of this chunk in bytes */
	__le64 length;

	/* objectid of the root referencing this chunk */
201
	__le64 owner;
202

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
	__le64 stripe_len;
	__le64 type;

	/* optimal io alignment for this chunk */
	__le32 io_align;

	/* optimal io width for this chunk */
	__le32 io_width;

	/* minimal io size for this chunk */
	__le32 sector_size;

	/* 2^16 stripes is quite a lot, a second limit is the size of a single
	 * item in the btree
	 */
	__le16 num_stripes;
Chris Mason's avatar
Chris Mason committed
219
220
221

	/* sub stripes only matter for raid10 */
	__le16 sub_stripes;
222
223
224
225
226
227
228
229
230
231
232
	struct btrfs_stripe stripe;
	/* additional stripes go here */
} __attribute__ ((__packed__));

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

233
#define BTRFS_FSID_SIZE 16
234
235
#define BTRFS_HEADER_FLAG_WRITTEN (1 << 0)

236
237
238
/*
 * every tree block (leaf or node) starts with this header.
 */
239
struct btrfs_header {
240
	/* these first four must match the super block */
Chris Mason's avatar
Chris Mason committed
241
	u8 csum[BTRFS_CSUM_SIZE];
242
	u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
243
	__le64 bytenr; /* which block this node is supposed to live in */
244
	__le64 flags;
245
246
247

	/* allowed to be different from the super from here on down */
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
248
	__le64 generation;
249
	__le64 owner;
250
	__le32 nritems;
251
	u8 level;
252
253
} __attribute__ ((__packed__));

254
#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
255
			        sizeof(struct btrfs_header)) / \
256
			        sizeof(struct btrfs_key_ptr))
257
#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
258
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
259
260
261
#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
					sizeof(struct btrfs_item) - \
					sizeof(struct btrfs_file_extent_item))
262

263
264
265
266
267
268

/*
 * 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
269
#define BTRFS_LABEL_SIZE 256
270

271
272
273
274
/*
 * the super block basically lists the main trees of the FS
 * it currently lacks any block count etc etc
 */
275
struct btrfs_super_block {
Chris Mason's avatar
Chris Mason committed
276
	u8 csum[BTRFS_CSUM_SIZE];
277
	/* the first 4 fields must match struct btrfs_header */
278
	u8 fsid[16];    /* FS specific uuid */
279
	__le64 bytenr; /* this block number */
280
	__le64 flags;
281
282

	/* allowed to be different from the btrfs_header from here own down */
283
284
285
	__le64 magic;
	__le64 generation;
	__le64 root;
286
	__le64 chunk_root;
287
	__le64 log_root;
288
289
	__le64 total_bytes;
	__le64 bytes_used;
290
	__le64 root_dir_objectid;
291
	__le64 num_devices;
292
293
294
	__le32 sectorsize;
	__le32 nodesize;
	__le32 leafsize;
295
	__le32 stripesize;
296
	__le32 sys_chunk_array_size;
297
	u8 root_level;
298
	u8 chunk_root_level;
299
	u8 log_root_level;
300
	struct btrfs_dev_item dev_item;
301
	char label[BTRFS_LABEL_SIZE];
302
	u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
Chris Mason's avatar
Chris Mason committed
303
304
} __attribute__ ((__packed__));

305
/*
306
 * A leaf is full of items. offset and size tell us where to find
307
308
 * the item in the leaf (relative to the start of the data area)
 */
Chris Mason's avatar
Chris Mason committed
309
struct btrfs_item {
Chris Mason's avatar
Chris Mason committed
310
	struct btrfs_disk_key key;
311
	__le32 offset;
312
	__le32 size;
313
314
} __attribute__ ((__packed__));

315
316
317
318
319
320
321
/*
 * 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.
 */
322
struct btrfs_leaf {
323
	struct btrfs_header header;
324
	struct btrfs_item items[];
325
326
} __attribute__ ((__packed__));

327
328
329
330
/*
 * all non-leaf blocks are nodes, they hold only keys and pointers to
 * other blocks
 */
331
332
333
struct btrfs_key_ptr {
	struct btrfs_disk_key key;
	__le64 blockptr;
334
	__le64 generation;
335
336
} __attribute__ ((__packed__));

337
struct btrfs_node {
338
	struct btrfs_header header;
339
	struct btrfs_key_ptr ptrs[];
340
341
} __attribute__ ((__packed__));

342
/*
343
344
 * 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
345
346
347
348
349
 * to any other levels that are present.
 *
 * The slots array records the index of the item or block pointer
 * used while walking the tree.
 */
350
struct btrfs_path {
351
	struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
352
	int slots[BTRFS_MAX_LEVEL];
353
354
	/* if there is real range locking, this locks field will change */
	int locks[BTRFS_MAX_LEVEL];
355
	int reada;
356
357
	/* keep some upper locks as we walk down */
	int keep_locks;
358
	int skip_locking;
359
	int lowest_level;
360
};
Chris Mason's avatar
Chris Mason committed
361

362
363
364
365
366
367
/*
 * items in the extent btree are used to record the objectid of the
 * owner of the block and the number of references
 */
struct btrfs_extent_item {
	__le32 refs;
368
369
370
371
372
373
374
} __attribute__ ((__packed__));

struct btrfs_extent_ref {
	__le64 root;
	__le64 generation;
	__le64 objectid;
	__le64 offset;
Zheng Yan's avatar
Zheng Yan committed
375
	__le32 num_refs;
376
377
} __attribute__ ((__packed__));

378
379
/* dev extents record free space on individual devices.  The owner
 * field points back to the chunk allocation mapping tree that allocated
380
 * the extent.  The chunk tree uuid field is a way to double check the owner
381
382
 */
struct btrfs_dev_extent {
383
384
385
	__le64 chunk_tree;
	__le64 chunk_objectid;
	__le64 chunk_offset;
386
	__le64 length;
387
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
388
389
} __attribute__ ((__packed__));

390
struct btrfs_inode_ref {
391
	__le64 index;
392
393
394
395
	__le16 name_len;
	/* name goes here */
} __attribute__ ((__packed__));

396
struct btrfs_timespec {
Chris Mason's avatar
Chris Mason committed
397
	__le64 sec;
Chris Mason's avatar
Chris Mason committed
398
399
400
401
402
403
404
405
	__le32 nsec;
} __attribute__ ((__packed__));

/*
 * there is no padding here on purpose.  If you want to extent the inode,
 * make a new item type
 */
struct btrfs_inode_item {
406
	/* nfs style generation number */
Chris Mason's avatar
Chris Mason committed
407
	__le64 generation;
408
409
	/* transid that last touched this inode */
	__le64 transid;
Chris Mason's avatar
Chris Mason committed
410
411
	__le64 size;
	__le64 nblocks;
412
	__le64 block_group;
Chris Mason's avatar
Chris Mason committed
413
414
415
416
	__le32 nlink;
	__le32 uid;
	__le32 gid;
	__le32 mode;
417
	__le64 rdev;
Chris Mason's avatar
Chris Mason committed
418
419
	__le16 flags;
	__le16 compat_flags;
420
421
422
423
	struct btrfs_timespec atime;
	struct btrfs_timespec ctime;
	struct btrfs_timespec mtime;
	struct btrfs_timespec otime;
Chris Mason's avatar
Chris Mason committed
424
425
} __attribute__ ((__packed__));

426
427
428
429
struct btrfs_dir_log_item {
	__le64 end;
} __attribute__ ((__packed__));

430
struct btrfs_dir_item {
431
	struct btrfs_disk_key location;
432
	__le64 transid;
Josef Bacik's avatar
Josef Bacik committed
433
	__le16 data_len;
434
	__le16 name_len;
435
436
437
438
	u8 type;
} __attribute__ ((__packed__));

struct btrfs_root_item {
439
440
	struct btrfs_inode_item inode;
	__le64 root_dirid;
441
442
443
	__le64 bytenr;
	__le64 byte_limit;
	__le64 bytes_used;
444
	__le32 flags;
445
	__le32 refs;
446
447
	struct btrfs_disk_key drop_progress;
	u8 drop_level;
448
	u8 level;
449
} __attribute__ ((__packed__));
450

451
452
453
#define BTRFS_FILE_EXTENT_REG 0
#define BTRFS_FILE_EXTENT_INLINE 1

454
struct btrfs_file_extent_item {
455
	__le64 generation;
456
	u8 type;
457
458
459
460
	/*
	 * disk space consumed by the extent, checksum blocks are included
	 * in these numbers
	 */
461
462
	__le64 disk_bytenr;
	__le64 disk_num_bytes;
463
	/*
Chris Mason's avatar
Chris Mason committed
464
	 * the logical offset in file blocks (no csums)
465
466
467
468
469
470
471
472
473
	 * this extent record is for.  This allows a file extent to point
	 * into the middle of an existing extent on disk, sharing it
	 * between two snapshots (useful if some bytes in the middle of the
	 * extent have changed
	 */
	__le64 offset;
	/*
	 * the logical number of file blocks (no csums included)
	 */
474
	__le64 num_bytes;
475
476
} __attribute__ ((__packed__));

Chris Mason's avatar
Chris Mason committed
477
struct btrfs_csum_item {
478
	u8 csum;
Chris Mason's avatar
Chris Mason committed
479
480
} __attribute__ ((__packed__));

481
482
483
484
/* different types of block groups (and chunks) */
#define BTRFS_BLOCK_GROUP_DATA     (1 << 0)
#define BTRFS_BLOCK_GROUP_SYSTEM   (1 << 1)
#define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
485
#define BTRFS_BLOCK_GROUP_RAID0    (1 << 3)
486
#define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)
487
#define BTRFS_BLOCK_GROUP_DUP	   (1 << 5)
Chris Mason's avatar
Chris Mason committed
488
#define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)
Chris Mason's avatar
Chris Mason committed
489

Chris Mason's avatar
Chris Mason committed
490
491
struct btrfs_block_group_item {
	__le64 used;
492
493
	__le64 chunk_objectid;
	__le64 flags;
Chris Mason's avatar
Chris Mason committed
494
495
} __attribute__ ((__packed__));

496
497
498
499
500
501
struct btrfs_space_info {
	u64 flags;
	u64 total_bytes;
	u64 bytes_used;
	u64 bytes_pinned;
	int full;
502
	int force_alloc;
503
	struct list_head list;
504
505
506
507
508
509
510
511
512
513
514

	/* for block groups in our same type */
	struct list_head block_groups;
	spinlock_t lock;
};

struct btrfs_free_space {
	struct rb_node bytes_index;
	struct rb_node offset_index;
	u64 offset;
	u64 bytes;
515
516
};

Chris Mason's avatar
Chris Mason committed
517
518
519
struct btrfs_block_group_cache {
	struct btrfs_key key;
	struct btrfs_block_group_item item;
520
	spinlock_t lock;
521
	u64 pinned;
522
523
	u64 flags;
	int cached;
524
	int ro;
525
526
527
528
529
530
531
532
533
534
535
536
537
	int dirty;

	struct btrfs_space_info *space_info;

	/* free space cache stuff */
	struct rb_root free_space_bytes;
	struct rb_root free_space_offset;

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

	/* for block groups in the same raid type */
	struct list_head list;
Chris Mason's avatar
Chris Mason committed
538
};
539
540

struct btrfs_device;
541
struct btrfs_fs_devices;
542
struct btrfs_fs_info {
543
	u8 fsid[BTRFS_FSID_SIZE];
544
	u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
545
546
	struct btrfs_root *extent_root;
	struct btrfs_root *tree_root;
547
548
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
549
550
551

	/* the log root tree is a directory of all the other log roots */
	struct btrfs_root *log_root_tree;
552
	struct radix_tree_root fs_roots_radix;
553

554
555
556
557
	/* block group cache stuff */
	spinlock_t block_group_cache_lock;
	struct rb_root block_group_cache_tree;

558
559
560
	struct extent_io_tree pinned_extents;
	struct extent_io_tree pending_del;
	struct extent_io_tree extent_ins;
561

562
563
564
	/* logical->physical extent mapping */
	struct btrfs_mapping_tree mapping_tree;

565
	u64 generation;
566
	u64 last_trans_committed;
567
	u64 last_trans_new_blockgroup;
568
	u64 open_ioctl_trans;
569
	unsigned long mount_opt;
570
	u64 max_extent;
571
	u64 max_inline;
572
	u64 alloc_start;
Chris Mason's avatar
Chris Mason committed
573
	struct btrfs_transaction *running_transaction;
574
	wait_queue_head_t transaction_throttle;
575
	wait_queue_head_t transaction_wait;
576
	wait_queue_head_t async_submit_wait;
577
578
579

	wait_queue_head_t tree_log_wait;

580
	struct btrfs_super_block super_copy;
581
	struct btrfs_super_block super_for_commit;
582
	struct block_device *__bdev;
Chris Mason's avatar
Chris Mason committed
583
	struct super_block *sb;
584
	struct inode *btree_inode;
Chris Mason's avatar
Chris Mason committed
585
	struct backing_dev_info bdi;
586
	spinlock_t hash_lock;
Chris Mason's avatar
Chris Mason committed
587
	struct mutex trans_mutex;
588
	struct mutex tree_log_mutex;
589
590
	struct mutex transaction_kthread_mutex;
	struct mutex cleaner_mutex;
591
592
	struct mutex alloc_mutex;
	struct mutex chunk_mutex;
593
	struct mutex drop_mutex;
594
	struct mutex volume_mutex;
Chris Mason's avatar
Chris Mason committed
595
	struct list_head trans_list;
596
	struct list_head hashers;
597
	struct list_head dead_roots;
598

599
	atomic_t nr_async_submits;
600
	atomic_t nr_async_bios;
601
602
603
604
	atomic_t tree_log_writers;
	atomic_t tree_log_commit;
	unsigned long tree_log_batch;
	u64 tree_log_transid;
605

606
607
608
609
610
611
	/*
	 * this is used by the balancing code to wait for all the pending
	 * ordered extents
	 */
	spinlock_t ordered_extent_lock;
	struct list_head ordered_extents;
612
	struct list_head delalloc_inodes;
613

614
615
616
617
618
619
	/*
	 * 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.
620
621
622
	 *
	 * A third pool does submit_bio to avoid deadlocking with the other
	 * two
623
624
625
	 */
	struct btrfs_workers workers;
	struct btrfs_workers endio_workers;
626
	struct btrfs_workers endio_write_workers;
627
	struct btrfs_workers submit_workers;
628
629
630
631
632
633
	/*
	 * 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
	 */
	struct btrfs_workers fixup_workers;
634
635
	struct task_struct *transaction_kthread;
	struct task_struct *cleaner_kthread;
636
	int thread_pool_size;
637

638
639
	struct kobject super_kobj;
	struct completion kobj_unregister;
640
	int do_barriers;
641
	int closing;
642
	int log_root_recovering;
643
	atomic_t throttles;
644
	atomic_t throttle_gen;
645

646
	u64 total_pinned;
647
648
	struct list_head dirty_cowonly_roots;

649
	struct btrfs_fs_devices *fs_devices;
650
	struct list_head space_info;
651
	spinlock_t delalloc_lock;
652
	spinlock_t new_trans_lock;
653
	u64 delalloc_bytes;
654
	u64 last_alloc;
655
	u64 last_data_alloc;
656
	u64 last_log_alloc;
657

Yan Zheng's avatar
Yan Zheng committed
658
659
660
	spinlock_t ref_cache_lock;
	u64 total_ref_cache_size;

661
662
663
664
665
666
	u64 avail_data_alloc_bits;
	u64 avail_metadata_alloc_bits;
	u64 avail_system_alloc_bits;
	u64 data_alloc_profile;
	u64 metadata_alloc_profile;
	u64 system_alloc_profile;
667
668

	void *bdev_holder;
669
};
670

671
672
673
674
675
676
677
struct btrfs_leaf_ref_tree {
	struct rb_root root;
	struct btrfs_leaf_ref *last;
	struct list_head list;
	spinlock_t lock;
};

678
679
/*
 * in ram representation of the tree.  extent_root is used for all allocations
680
 * and for the extent tree extent_root root.
681
 */
682
struct btrfs_dirty_root;
683
struct btrfs_root {
684
	struct extent_buffer *node;
685
686
687
688

	/* the node lock is held while changing the node pointer */
	spinlock_t node_lock;

689
	struct extent_buffer *commit_root;
Yan Zheng's avatar
Yan Zheng committed
690
	struct btrfs_leaf_ref_tree *ref_tree;
691
	struct btrfs_leaf_ref_tree ref_tree_struct;
692
	struct btrfs_dirty_root *dirty_root;
693
	struct btrfs_root *log_root;
Yan Zheng's avatar
Yan Zheng committed
694

695
696
	struct btrfs_root_item root_item;
	struct btrfs_key root_key;
697
	struct btrfs_fs_info *fs_info;
698
	struct inode *inode;
699
700
	struct extent_io_tree dirty_log_pages;

701
702
	struct kobject root_kobj;
	struct completion kobj_unregister;
703
	struct mutex objectid_mutex;
704
	struct mutex log_mutex;
705

706
707
	u64 objectid;
	u64 last_trans;
708
709
710
711
712
713
714
715
716
717

	/* data allocations are done in sectorsize units */
	u32 sectorsize;

	/* node allocations are done in nodesize units */
	u32 nodesize;

	/* leaf allocations are done in leafsize units */
	u32 leafsize;

718
719
	u32 stripesize;

720
	u32 type;
Chris Mason's avatar
Chris Mason committed
721
722
	u64 highest_inode;
	u64 last_inode_alloc;
723
	int ref_cows;
724
	int track_dirty;
725
	u64 defrag_trans_start;
726
	struct btrfs_key defrag_progress;
727
	struct btrfs_key defrag_max;
728
729
	int defrag_running;
	int defrag_level;
730
	char *name;
731
	int in_sysfs;
732
733
734

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

736
737
	spinlock_t list_lock;
	struct list_head dead_list;
738
	struct list_head orphan_list;
739
740
};

Chris Mason's avatar
Chris Mason committed
741
/*
742

Chris Mason's avatar
Chris Mason committed
743
744
745
746
 * inode items have the data typically returned from stat and store other
 * info about object characteristics.  There is one for every file and dir in
 * the FS
 */
Chris Mason's avatar
Chris Mason committed
747
#define BTRFS_INODE_ITEM_KEY		1
748
749
#define BTRFS_INODE_REF_KEY		2
#define BTRFS_XATTR_ITEM_KEY		8
750
#define BTRFS_ORPHAN_ITEM_KEY		9
Chris Mason's avatar
Chris Mason committed
751
/* reserve 2-15 close to the inode for later flexibility */
Chris Mason's avatar
Chris Mason committed
752
753
754
755
756

/*
 * dir items are the name -> inode pointers in a directory.  There is one
 * for every name in a directory.
 */
757
758
#define BTRFS_DIR_LOG_ITEM_KEY  14
#define BTRFS_DIR_LOG_INDEX_KEY 15
Chris Mason's avatar
Chris Mason committed
759
760
#define BTRFS_DIR_ITEM_KEY	16
#define BTRFS_DIR_INDEX_KEY	17
Chris Mason's avatar
Chris Mason committed
761
/*
Chris Mason's avatar
Chris Mason committed
762
 * extent data is for file data
Chris Mason's avatar
Chris Mason committed
763
 */
Chris Mason's avatar
Chris Mason committed
764
#define BTRFS_EXTENT_DATA_KEY	18
Chris Mason's avatar
Chris Mason committed
765
766
767
/*
 * csum items have the checksums for data in the extents
 */
Chris Mason's avatar
Chris Mason committed
768
769
#define BTRFS_CSUM_ITEM_KEY	19

770
771

/* reserve 21-31 for other file/dir stuff */
Chris Mason's avatar
Chris Mason committed
772

Chris Mason's avatar
Chris Mason committed
773
774
775
776
/*
 * root items point to tree roots.  There are typically in the root
 * tree used by the super block to find all the other trees
 */
Chris Mason's avatar
Chris Mason committed
777
#define BTRFS_ROOT_ITEM_KEY	32
Chris Mason's avatar
Chris Mason committed
778
779
780
781
/*
 * extent items are in the extent map tree.  These record which blocks
 * are used, and how many references there are to each block
 */
Chris Mason's avatar
Chris Mason committed
782
#define BTRFS_EXTENT_ITEM_KEY	33
783
#define BTRFS_EXTENT_REF_KEY	34
Chris Mason's avatar
Chris Mason committed
784
785
786
787
788

/*
 * block groups give us hints into the extent allocation trees.  Which
 * blocks are free etc etc
 */
789
#define BTRFS_BLOCK_GROUP_ITEM_KEY 50
790

791
792
793
794
#define BTRFS_DEV_EXTENT_KEY	75
#define BTRFS_DEV_ITEM_KEY	76
#define BTRFS_CHUNK_ITEM_KEY	77

Chris Mason's avatar
Chris Mason committed
795
796
797
798
/*
 * string items are for debugging.  They just store a short string of
 * data in the FS
 */
Chris Mason's avatar
Chris Mason committed
799
800
#define BTRFS_STRING_ITEM_KEY	253

801
802
803
#define BTRFS_MOUNT_NODATASUM		(1 << 0)
#define BTRFS_MOUNT_NODATACOW		(1 << 1)
#define BTRFS_MOUNT_NOBARRIER		(1 << 2)
804
#define BTRFS_MOUNT_SSD			(1 << 3)
805
#define BTRFS_MOUNT_DEGRADED		(1 << 4)
806
807
808
809
810

#define btrfs_clear_opt(o, opt)		((o) &= ~BTRFS_MOUNT_##opt)
#define btrfs_set_opt(o, opt)		((o) |= BTRFS_MOUNT_##opt)
#define btrfs_test_opt(root, opt)	((root)->fs_info->mount_opt & \
					 BTRFS_MOUNT_##opt)
Yan's avatar
Yan committed
811
812
813
/*
 * Inode flags
 */
Yan's avatar
Yan committed
814
815
816
#define BTRFS_INODE_NODATASUM		(1 << 0)
#define BTRFS_INODE_NODATACOW		(1 << 1)
#define BTRFS_INODE_READONLY		(1 << 2)
Yan's avatar
Yan committed
817
818
819
820
821
822
#define btrfs_clear_flag(inode, flag)	(BTRFS_I(inode)->flags &= \
					 ~BTRFS_INODE_##flag)
#define btrfs_set_flag(inode, flag)	(BTRFS_I(inode)->flags |= \
					 BTRFS_INODE_##flag)
#define btrfs_test_flag(inode, flag)	(BTRFS_I(inode)->flags & \
					 BTRFS_INODE_##flag)
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
/* some macros to generate set/get funcs for the struct fields.  This
 * 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

#define read_eb_member(eb, ptr, type, member, result) (			\
	read_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

#define write_eb_member(eb, ptr, type, member, result) (		\
	write_extent_buffer(eb, (char *)(result),			\
			   ((unsigned long)(ptr)) +			\
			    offsetof(type, member),			\
			   sizeof(((type *)0)->member)))

843
#ifndef BTRFS_SETGET_FUNCS
844
#define BTRFS_SETGET_FUNCS(name, type, member, bits)			\
845
846
847
u##bits btrfs_##name(struct extent_buffer *eb, type *s);		\
void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
#endif
848
849
850
851

#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)		\
static inline u##bits btrfs_##name(struct extent_buffer *eb)		\
{									\
David Miller's avatar
David Miller committed
852
853
854
	type *p = kmap_atomic(eb->first_page, KM_USER0);		\
	u##bits res = le##bits##_to_cpu(p->member);			\
	kunmap_atomic(p, KM_USER0);					\
855
	return res;							\
856
857
858
859
}									\
static inline void btrfs_set_##name(struct extent_buffer *eb,		\
				    u##bits val)			\
{									\
David Miller's avatar
David Miller committed
860
861
862
	type *p = kmap_atomic(eb->first_page, KM_USER0);		\
	p->member = cpu_to_le##bits(val);				\
	kunmap_atomic(p, KM_USER0);					\
863
}
Chris Mason's avatar
Chris Mason committed
864

865
866
867
868
869
870
871
872
#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);				\
Chris Mason's avatar
Chris Mason committed
873
874
}

875
876
877
878
879
880
881
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);
BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
882
883
884
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);
885

886
887
888
889
890
891
892
893
894
895
896
897
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);
898
899
900
901
902
903
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);
904

905
906
907
908
909
static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
{
	return (char *)d + offsetof(struct btrfs_dev_item, uuid);
}

910
BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
911
912
913
914
915
916
917
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);
Chris Mason's avatar
Chris Mason committed
918
BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
919
920
921
BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);

922
923
924
925
926
927
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);
928
929
930
931
932
933
934
935
936
937
938
939
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);
Chris Mason's avatar
Chris Mason committed
940
941
BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
			 sub_stripes, 16);
942
943
944
945
946
947
948
949
950
951
952
953
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;
}

954
955
956
957
958
static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
{
	return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
}

959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
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 void btrfs_set_stripe_offset_nr(struct extent_buffer *eb,
					     struct btrfs_chunk *c, int nr,
					     u64 val)
{
	btrfs_set_stripe_offset(eb, btrfs_stripe_nr(c, nr), val);
}

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

static inline void btrfs_set_stripe_devid_nr(struct extent_buffer *eb,
					     struct btrfs_chunk *c, int nr,
					     u64 val)
{
	btrfs_set_stripe_devid(eb, btrfs_stripe_nr(c, nr), val);
}

985
986
987
988
989
/* 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);
990
991
BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
			struct btrfs_block_group_item, chunk_objectid, 64);
992
993

BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
994
995
996
997
998
		   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);
Chris Mason's avatar
Chris Mason committed
999

1000
/* struct btrfs_inode_ref */
For faster browsing, not all history is shown. View entire blame