blob: 0b180708bf79d87a36c9dcc78bbd6d72772101df [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
Chris Masondc17ff82008-01-08 15:46:30 -050019#ifndef __BTRFS_CTREE__
20#define __BTRFS_CTREE__
Chris Masoneb60cea2007-02-02 09:18:22 -050021
Chris Mason810191f2007-10-15 16:18:55 -040022#include <linux/mm.h>
23#include <linux/highmem.h>
Chris Masone20d96d2007-03-22 12:13:20 -040024#include <linux/fs.h>
Arne Jansena2de7332011-03-08 14:14:00 +010025#include <linux/rwsem.h>
Stefan Behrens803b2f52013-08-15 17:11:21 +020026#include <linux/semaphore.h>
Josef Bacik58176a92007-08-29 15:47:34 -040027#include <linux/completion.h>
Chris Mason04160082008-03-26 10:28:07 -040028#include <linux/backing-dev.h>
Chris Masone6dcd2d2008-07-17 12:53:50 -040029#include <linux/wait.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Stefan Schmidtf8b18082011-01-12 10:30:42 +010031#include <linux/kobject.h>
liubo1abe9b82011-03-24 11:18:59 +000032#include <trace/events/btrfs.h>
Chris Mason479965d2007-10-15 16:14:27 -040033#include <asm/kmap_types.h>
Josef Bacik3b16a4e2011-09-21 15:05:58 -040034#include <linux/pagemap.h>
Filipe Brandenburger55e301f2013-01-29 06:04:50 +000035#include <linux/btrfs.h>
Miao Xie21c7e752014-05-13 17:29:04 -070036#include <linux/workqueue.h>
Qu Wenruof667aef2014-09-23 13:40:08 +080037#include <linux/security.h>
Chris Masond1310b22008-01-24 16:13:08 -050038#include "extent_io.h"
Chris Mason5f39d392007-10-15 16:14:19 -040039#include "extent_map.h"
Chris Mason8b712842008-06-11 16:50:36 -040040#include "async-thread.h"
Chris Masone20d96d2007-03-22 12:13:20 -040041
Chris Masone089f052007-03-16 16:20:31 -040042struct btrfs_trans_handle;
Chris Mason79154b12007-03-22 15:59:16 -040043struct btrfs_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -040044struct btrfs_pending_snapshot;
Chris Mason35b7e472007-05-02 15:53:43 -040045extern struct kmem_cache *btrfs_trans_handle_cachep;
46extern struct kmem_cache *btrfs_transaction_cachep;
47extern struct kmem_cache *btrfs_bit_radix_cachep;
Chris Mason2c90e5d2007-04-02 10:50:19 -040048extern struct kmem_cache *btrfs_path_cachep;
Josef Bacikdc89e982011-01-28 17:05:48 -050049extern struct kmem_cache *btrfs_free_space_cachep;
Chris Masone6dcd2d2008-07-17 12:53:50 -040050struct btrfs_ordered_sum;
Chris Masone089f052007-03-16 16:20:31 -040051
Josef Bacik294e30f2013-10-09 12:00:56 -040052#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
53#define STATIC noinline
54#else
55#define STATIC static noinline
56#endif
57
Zach Browncdb4c572013-02-20 00:55:13 +000058#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
Chris Masoneb60cea2007-02-02 09:18:22 -050059
Stefan Behrens72d7aef2012-11-06 14:57:46 +010060#define BTRFS_MAX_MIRRORS 3
Stefan Behrens94598ba2012-03-27 14:21:26 -040061
Chris Mason4008c042009-02-12 14:09:45 -050062#define BTRFS_MAX_LEVEL 8
Chris Mason0b86a832008-03-24 15:01:56 -040063
Yan Zheng5d4f98a2009-06-10 10:45:14 -040064#define BTRFS_COMPAT_EXTENT_TREE_V0
65
Chris Mason0b86a832008-03-24 15:01:56 -040066/* holds pointers to all of the tree roots */
Chris Mason6407bf62007-03-27 06:33:00 -040067#define BTRFS_ROOT_TREE_OBJECTID 1ULL
Chris Mason0b86a832008-03-24 15:01:56 -040068
69/* stores information about which extents are in use, and reference counts */
Chris Mason0cf6c622007-06-09 09:22:25 -040070#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
Chris Mason0b86a832008-03-24 15:01:56 -040071
Chris Mason0b86a832008-03-24 15:01:56 -040072/*
73 * chunk tree stores translations from logical -> physical block numbering
74 * the super block points to the chunk tree
75 */
Chris Masone085def2008-03-24 15:02:07 -040076#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
Chris Mason0b86a832008-03-24 15:01:56 -040077
78/*
79 * stores information about which areas of a given device are in use.
80 * one per device. The tree of tree roots points to the device tree
81 */
Chris Masone085def2008-03-24 15:02:07 -040082#define BTRFS_DEV_TREE_OBJECTID 4ULL
83
84/* one per subvolume, storing files and directories */
85#define BTRFS_FS_TREE_OBJECTID 5ULL
86
87/* directory objectid inside the root tree */
88#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
Chris Mason0b86a832008-03-24 15:01:56 -040089
Chris Masond20f7042008-12-08 16:58:54 -050090/* holds checksums of all the data extents */
91#define BTRFS_CSUM_TREE_OBJECTID 7ULL
92
Arne Jansen630dc772011-09-13 11:06:07 +020093/* holds quota configuration and tracking */
94#define BTRFS_QUOTA_TREE_OBJECTID 8ULL
95
Stefan Behrens07b30a42013-08-15 17:11:17 +020096/* for storing items that use the BTRFS_UUID_KEY* types */
97#define BTRFS_UUID_TREE_OBJECTID 9ULL
98
David Sterba60b62972013-04-30 17:29:29 +000099/* for storing balance parameters in the root tree */
100#define BTRFS_BALANCE_OBJECTID -4ULL
101
Josef Bacik7b128762008-07-24 12:17:14 -0400102/* orhpan objectid for tracking unlinked/truncated files */
103#define BTRFS_ORPHAN_OBJECTID -5ULL
104
Chris Masone02119d2008-09-05 16:13:11 -0400105/* does write ahead logging to speed up fsyncs */
106#define BTRFS_TREE_LOG_OBJECTID -6ULL
107#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
108
Zheng Yane4657682008-09-26 10:04:53 -0400109/* for space balancing */
110#define BTRFS_TREE_RELOC_OBJECTID -8ULL
111#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
112
Chris Masond20f7042008-12-08 16:58:54 -0500113/*
114 * extent checksums all have this objectid
115 * this allows them to share the logging tree
116 * for fsyncs
117 */
118#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
119
Josef Bacik0af3d002010-06-21 14:48:16 -0400120/* For storing free space cache */
121#define BTRFS_FREE_SPACE_OBJECTID -11ULL
122
Li Zefan82d59022011-04-20 10:33:24 +0800123/*
Wang Sheng-Hui527a1362012-09-06 13:33:37 +0800124 * The inode number assigned to the special inode for storing
Li Zefan82d59022011-04-20 10:33:24 +0800125 * free ino cache
126 */
127#define BTRFS_FREE_INO_OBJECTID -12ULL
128
Zheng Yan31840ae2008-09-23 13:14:14 -0400129/* dummy objectid represents multiple objectids */
130#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
131
Chris Mason0b86a832008-03-24 15:01:56 -0400132/*
Zheng Yan6527cdb2008-09-05 16:43:53 -0400133 * All files have objectids in this range.
Chris Mason0b86a832008-03-24 15:01:56 -0400134 */
Chris Masonf6dbff52007-12-13 11:13:32 -0500135#define BTRFS_FIRST_FREE_OBJECTID 256ULL
Zheng Yan6527cdb2008-09-05 16:43:53 -0400136#define BTRFS_LAST_FREE_OBJECTID -256ULL
Chris Masone17cade2008-04-15 15:41:47 -0400137#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
Chris Mason3768f362007-03-13 16:47:54 -0400138
Chris Mason0b86a832008-03-24 15:01:56 -0400139
140/*
141 * the device items go into the chunk tree. The key is in the form
142 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
143 */
144#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
145
Yan, Zheng4df27c4d2009-09-21 15:56:00 -0400146#define BTRFS_BTREE_INODE_OBJECTID 1
147
148#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
149
Geert Uytterhoeven6e71c472013-08-20 13:20:08 +0200150#define BTRFS_DEV_REPLACE_DEVID 0ULL
Stefan Behrense93c89c2012-11-05 17:33:06 +0100151
Chris Masonfec577f2007-02-26 10:40:21 -0500152/*
Chris Mason727011e2010-08-06 13:21:20 -0400153 * the max metadata block size. This limit is somewhat artificial,
154 * but the memmove costs go through the roof for larger blocks.
155 */
156#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
157
158/*
Chris Masone20d96d2007-03-22 12:13:20 -0400159 * we can actually store much bigger names, but lets not confuse the rest
160 * of linux
161 */
162#define BTRFS_NAME_LEN 255
163
Mark Fashehf1863732012-08-08 11:32:27 -0700164/*
165 * Theoretical limit is larger, but we keep this down to a sane
166 * value. That should limit greatly the possibility of collisions on
167 * inode ref items.
168 */
169#define BTRFS_LINK_MAX 65535U
170
Chris Masonf254e522007-03-29 15:15:27 -0400171/* 32 bytes in various csum fields */
172#define BTRFS_CSUM_SIZE 32
Josef Bacik607d4322008-12-02 07:17:45 -0500173
174/* csum types */
175#define BTRFS_CSUM_TYPE_CRC32 0
176
177static int btrfs_csum_sizes[] = { 4, 0 };
178
Chris Mason509659c2007-05-10 12:36:17 -0400179/* four bytes for CRC32 */
Chris Mason39544012007-12-12 14:38:19 -0500180#define BTRFS_EMPTY_DIR_SIZE 0
Chris Masonf254e522007-03-29 15:15:27 -0400181
Stefan Behrens29a8d9a2012-11-06 14:16:24 +0100182/* spefic to btrfs_map_block(), therefore not in include/linux/blk_types.h */
183#define REQ_GET_READ_MIRRORS (1 << 30)
184
Chris Masonfabb5682007-06-07 22:13:21 -0400185#define BTRFS_FT_UNKNOWN 0
186#define BTRFS_FT_REG_FILE 1
187#define BTRFS_FT_DIR 2
188#define BTRFS_FT_CHRDEV 3
189#define BTRFS_FT_BLKDEV 4
190#define BTRFS_FT_FIFO 5
191#define BTRFS_FT_SOCK 6
192#define BTRFS_FT_SYMLINK 7
Josef Bacik5103e942007-11-16 11:45:54 -0500193#define BTRFS_FT_XATTR 8
194#define BTRFS_FT_MAX 9
Chris Masonfabb5682007-06-07 22:13:21 -0400195
Stefan Behrens3d136a12012-02-03 11:20:04 +0100196/* ioprio of readahead is set to idle */
197#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
198
Miao Xiee2d84522013-01-29 10:09:20 +0000199#define BTRFS_DIRTY_METADATA_THRESH (32 * 1024 * 1024)
200
Chris Masone20d96d2007-03-22 12:13:20 -0400201/*
Wu Fengguangd4a78942009-04-02 16:46:06 -0400202 * The key defines the order in the tree, and so it also defines (optimal)
203 * block layout.
204 *
205 * objectid corresponds to the inode number.
206 *
207 * type tells us things about the object, and is a kind of stream selector.
208 * so for a given inode, keys with type of 1 might refer to the inode data,
209 * type of 2 may point to file data in the btree and type == 3 may point to
210 * extents.
Chris Masonfec577f2007-02-26 10:40:21 -0500211 *
212 * offset is the starting byte offset for this key in the stream.
Chris Masone2fa7222007-03-12 16:22:34 -0400213 *
214 * btrfs_disk_key is in disk byte order. struct btrfs_key is always
215 * in cpu native order. Otherwise they are identical and their sizes
216 * should be the same (ie both packed)
Chris Masonfec577f2007-02-26 10:40:21 -0500217 */
Chris Masone2fa7222007-03-12 16:22:34 -0400218struct btrfs_disk_key {
219 __le64 objectid;
Chris Mason5f39d392007-10-15 16:14:19 -0400220 u8 type;
Chris Mason70b2bef2007-04-17 15:39:32 -0400221 __le64 offset;
Chris Masone2fa7222007-03-12 16:22:34 -0400222} __attribute__ ((__packed__));
223
224struct btrfs_key {
Chris Masoneb60cea2007-02-02 09:18:22 -0500225 u64 objectid;
Chris Mason5f39d392007-10-15 16:14:19 -0400226 u8 type;
Chris Mason70b2bef2007-04-17 15:39:32 -0400227 u64 offset;
Chris Masoneb60cea2007-02-02 09:18:22 -0500228} __attribute__ ((__packed__));
229
Chris Mason0b86a832008-03-24 15:01:56 -0400230struct btrfs_mapping_tree {
231 struct extent_map_tree map_tree;
232};
233
Chris Mason0b86a832008-03-24 15:01:56 -0400234struct btrfs_dev_item {
235 /* the internal btrfs device id */
236 __le64 devid;
237
238 /* size of the device */
239 __le64 total_bytes;
240
241 /* bytes used */
242 __le64 bytes_used;
243
244 /* optimal io alignment for this device */
245 __le32 io_align;
246
247 /* optimal io width for this device */
248 __le32 io_width;
249
250 /* minimal io size for this device */
251 __le32 sector_size;
252
Chris Mason0b86a832008-03-24 15:01:56 -0400253 /* type and info about this device */
254 __le64 type;
255
Yan Zheng2b820322008-11-17 21:11:30 -0500256 /* expected generation for this device */
257 __le64 generation;
258
Chris Masonc3027eb2008-12-08 16:40:21 -0500259 /*
260 * starting byte of this partition on the device,
Wu Fengguangd4a78942009-04-02 16:46:06 -0400261 * to allow for stripe alignment in the future
Chris Masonc3027eb2008-12-08 16:40:21 -0500262 */
263 __le64 start_offset;
264
Chris Masone17cade2008-04-15 15:41:47 -0400265 /* grouping information for allocation decisions */
266 __le32 dev_group;
267
268 /* seek speed 0-100 where 100 is fastest */
269 u8 seek_speed;
270
271 /* bandwidth 0-100 where 100 is fastest */
272 u8 bandwidth;
273
Chris Mason0d81ba52008-03-24 15:02:07 -0400274 /* btrfs generated uuid for this device */
Chris Masone17cade2008-04-15 15:41:47 -0400275 u8 uuid[BTRFS_UUID_SIZE];
Yan Zheng2b820322008-11-17 21:11:30 -0500276
277 /* uuid of FS who owns this device */
278 u8 fsid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400279} __attribute__ ((__packed__));
280
281struct btrfs_stripe {
282 __le64 devid;
283 __le64 offset;
Chris Masone17cade2008-04-15 15:41:47 -0400284 u8 dev_uuid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400285} __attribute__ ((__packed__));
286
287struct btrfs_chunk {
Chris Masone17cade2008-04-15 15:41:47 -0400288 /* size of this chunk in bytes */
289 __le64 length;
290
291 /* objectid of the root referencing this chunk */
Chris Mason0b86a832008-03-24 15:01:56 -0400292 __le64 owner;
Chris Masone17cade2008-04-15 15:41:47 -0400293
Chris Mason0b86a832008-03-24 15:01:56 -0400294 __le64 stripe_len;
295 __le64 type;
296
297 /* optimal io alignment for this chunk */
298 __le32 io_align;
299
300 /* optimal io width for this chunk */
301 __le32 io_width;
302
303 /* minimal io size for this chunk */
304 __le32 sector_size;
305
306 /* 2^16 stripes is quite a lot, a second limit is the size of a single
307 * item in the btree
308 */
309 __le16 num_stripes;
Chris Mason321aecc2008-04-16 10:49:51 -0400310
311 /* sub stripes only matter for raid10 */
312 __le16 sub_stripes;
Chris Mason0b86a832008-03-24 15:01:56 -0400313 struct btrfs_stripe stripe;
314 /* additional stripes go here */
315} __attribute__ ((__packed__));
316
Josef Bacik0af3d002010-06-21 14:48:16 -0400317#define BTRFS_FREE_SPACE_EXTENT 1
318#define BTRFS_FREE_SPACE_BITMAP 2
319
320struct btrfs_free_space_entry {
321 __le64 offset;
322 __le64 bytes;
323 u8 type;
324} __attribute__ ((__packed__));
325
326struct btrfs_free_space_header {
327 struct btrfs_disk_key location;
328 __le64 generation;
329 __le64 num_entries;
330 __le64 num_bitmaps;
331} __attribute__ ((__packed__));
332
Chris Mason0b86a832008-03-24 15:01:56 -0400333static inline unsigned long btrfs_chunk_item_size(int num_stripes)
334{
335 BUG_ON(num_stripes == 0);
336 return sizeof(struct btrfs_chunk) +
337 sizeof(struct btrfs_stripe) * (num_stripes - 1);
338}
339
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400340#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
341#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
liuboacce9522011-01-06 19:30:25 +0800342
343/*
344 * File system states
345 */
Miao Xie87533c42013-01-29 10:14:48 +0000346#define BTRFS_FS_STATE_ERROR 0
Miao Xiedc81cdc2013-02-20 23:32:52 -0700347#define BTRFS_FS_STATE_REMOUNTING 1
David Sterba08748812013-03-12 14:46:08 +0000348#define BTRFS_FS_STATE_TRANS_ABORTED 2
Miao Xiec404e0d2014-01-30 16:46:55 +0800349#define BTRFS_FS_STATE_DEV_REPLACING 3
liuboacce9522011-01-06 19:30:25 +0800350
Miao Xie87533c42013-01-29 10:14:48 +0000351/* Super block flags */
liuboacce9522011-01-06 19:30:25 +0800352/* Errors detected */
353#define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)
354
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400355#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
356#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
357
358#define BTRFS_BACKREF_REV_MAX 256
359#define BTRFS_BACKREF_REV_SHIFT 56
360#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
361 BTRFS_BACKREF_REV_SHIFT)
362
363#define BTRFS_OLD_BACKREF_REV 0
364#define BTRFS_MIXED_BACKREF_REV 1
Chris Mason63b10fc2008-04-01 11:21:32 -0400365
Chris Masonfec577f2007-02-26 10:40:21 -0500366/*
367 * every tree block (leaf or node) starts with this header.
368 */
Chris Masonbb492bb2007-03-12 12:29:44 -0400369struct btrfs_header {
Chris Masone17cade2008-04-15 15:41:47 -0400370 /* these first four must match the super block */
Chris Masonf254e522007-03-29 15:15:27 -0400371 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason5f39d392007-10-15 16:14:19 -0400372 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400373 __le64 bytenr; /* which block this node is supposed to live in */
Chris Mason63b10fc2008-04-01 11:21:32 -0400374 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400375
376 /* allowed to be different from the super from here on down */
377 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason7f5c1512007-03-23 15:56:19 -0400378 __le64 generation;
Chris Mason4d775672007-04-20 20:23:12 -0400379 __le64 owner;
Chris Mason5f39d392007-10-15 16:14:19 -0400380 __le32 nritems;
Chris Mason9a6f11e2007-03-27 09:06:38 -0400381 u8 level;
Chris Masoneb60cea2007-02-02 09:18:22 -0500382} __attribute__ ((__packed__));
383
Chris Mason5f39d392007-10-15 16:14:19 -0400384#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
Chris Masond3977122009-01-05 21:25:51 -0500385 sizeof(struct btrfs_header)) / \
386 sizeof(struct btrfs_key_ptr))
Chris Mason123abc82007-03-14 14:14:43 -0400387#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
David Sterba707e8a02014-06-04 19:22:26 +0200388#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->nodesize))
David Sterba7ec20af2014-07-24 17:34:58 +0200389#define BTRFS_FILE_EXTENT_INLINE_DATA_START \
390 (offsetof(struct btrfs_file_extent_item, disk_bytenr))
Chris Mason236454d2007-04-19 13:37:44 -0400391#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
392 sizeof(struct btrfs_item) - \
David Sterba7ec20af2014-07-24 17:34:58 +0200393 BTRFS_FILE_EXTENT_INLINE_DATA_START)
Yan, Zhengf34f57a2009-11-12 09:35:27 +0000394#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
395 sizeof(struct btrfs_item) -\
396 sizeof(struct btrfs_dir_item))
Chris Masoneb60cea2007-02-02 09:18:22 -0500397
Chris Mason0b86a832008-03-24 15:01:56 -0400398
399/*
400 * this is a very generous portion of the super block, giving us
401 * room to translate 14 chunks with 3 stripes each.
402 */
403#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
Chris Mason7ae9c092008-04-18 10:29:49 -0400404#define BTRFS_LABEL_SIZE 256
Chris Mason0b86a832008-03-24 15:01:56 -0400405
Chris Masonfec577f2007-02-26 10:40:21 -0500406/*
Chris Masonaf31f5e2011-11-03 15:17:42 -0400407 * just in case we somehow lose the roots and are not able to mount,
408 * we store an array of the roots from previous transactions
409 * in the super.
410 */
411#define BTRFS_NUM_BACKUP_ROOTS 4
412struct btrfs_root_backup {
413 __le64 tree_root;
414 __le64 tree_root_gen;
415
416 __le64 chunk_root;
417 __le64 chunk_root_gen;
418
419 __le64 extent_root;
420 __le64 extent_root_gen;
421
422 __le64 fs_root;
423 __le64 fs_root_gen;
424
425 __le64 dev_root;
426 __le64 dev_root_gen;
427
428 __le64 csum_root;
429 __le64 csum_root_gen;
430
431 __le64 total_bytes;
432 __le64 bytes_used;
433 __le64 num_devices;
434 /* future */
Masanari Iidad1423242012-10-31 15:16:32 +0000435 __le64 unused_64[4];
Chris Masonaf31f5e2011-11-03 15:17:42 -0400436
437 u8 tree_root_level;
438 u8 chunk_root_level;
439 u8 extent_root_level;
440 u8 fs_root_level;
441 u8 dev_root_level;
442 u8 csum_root_level;
443 /* future and to align */
444 u8 unused_8[10];
445} __attribute__ ((__packed__));
446
447/*
Chris Masonfec577f2007-02-26 10:40:21 -0500448 * the super block basically lists the main trees of the FS
449 * it currently lacks any block count etc etc
450 */
Chris Mason234b63a2007-03-13 10:46:10 -0400451struct btrfs_super_block {
Chris Masonf254e522007-03-29 15:15:27 -0400452 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason63b10fc2008-04-01 11:21:32 -0400453 /* the first 4 fields must match struct btrfs_header */
Yan Zheng2b820322008-11-17 21:11:30 -0500454 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400455 __le64 bytenr; /* this block number */
Chris Mason63b10fc2008-04-01 11:21:32 -0400456 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400457
458 /* allowed to be different from the btrfs_header from here own down */
Chris Mason3768f362007-03-13 16:47:54 -0400459 __le64 magic;
Chris Mason3768f362007-03-13 16:47:54 -0400460 __le64 generation;
461 __le64 root;
Chris Mason0b86a832008-03-24 15:01:56 -0400462 __le64 chunk_root;
Chris Masone02119d2008-09-05 16:13:11 -0400463 __le64 log_root;
Chris Masonc3027eb2008-12-08 16:40:21 -0500464
465 /* this will help find the new super based on the log root */
466 __le64 log_root_transid;
Chris Masondb945352007-10-15 16:15:53 -0400467 __le64 total_bytes;
468 __le64 bytes_used;
Chris Mason2e635a22007-03-21 11:12:56 -0400469 __le64 root_dir_objectid;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400470 __le64 num_devices;
Chris Mason5f39d392007-10-15 16:14:19 -0400471 __le32 sectorsize;
472 __le32 nodesize;
David Sterba707e8a02014-06-04 19:22:26 +0200473 __le32 __unused_leafsize;
Chris Mason87ee04e2007-11-30 11:30:34 -0500474 __le32 stripesize;
Chris Mason0b86a832008-03-24 15:01:56 -0400475 __le32 sys_chunk_array_size;
Yan Zheng84234f32008-10-29 14:49:05 -0400476 __le64 chunk_root_generation;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500477 __le64 compat_flags;
478 __le64 compat_ro_flags;
479 __le64 incompat_flags;
Josef Bacik607d4322008-12-02 07:17:45 -0500480 __le16 csum_type;
Chris Masondb945352007-10-15 16:15:53 -0400481 u8 root_level;
Chris Mason0b86a832008-03-24 15:01:56 -0400482 u8 chunk_root_level;
Chris Masone02119d2008-09-05 16:13:11 -0400483 u8 log_root_level;
Chris Mason0d81ba52008-03-24 15:02:07 -0400484 struct btrfs_dev_item dev_item;
Chris Masonc3027eb2008-12-08 16:40:21 -0500485
Chris Mason7ae9c092008-04-18 10:29:49 -0400486 char label[BTRFS_LABEL_SIZE];
Chris Masonc3027eb2008-12-08 16:40:21 -0500487
Josef Bacik0af3d002010-06-21 14:48:16 -0400488 __le64 cache_generation;
Stefan Behrens26432792013-08-15 17:11:22 +0200489 __le64 uuid_tree_generation;
Josef Bacik0af3d002010-06-21 14:48:16 -0400490
Chris Masonc3027eb2008-12-08 16:40:21 -0500491 /* future expansion */
Stefan Behrens26432792013-08-15 17:11:22 +0200492 __le64 reserved[30];
Chris Mason0b86a832008-03-24 15:01:56 -0400493 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
Chris Masonaf31f5e2011-11-03 15:17:42 -0400494 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
Chris Masoncfaa7292007-02-21 17:04:57 -0500495} __attribute__ ((__packed__));
496
Chris Masonfec577f2007-02-26 10:40:21 -0500497/*
Josef Bacikf2b636e2008-12-02 06:36:08 -0500498 * Compat flags that we support. If any incompat flags are set other than the
499 * ones specified below then we will fail to mount
500 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400501#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
Josef Bacik0af3d002010-06-21 14:48:16 -0400502#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
Josef Bacik67377732010-09-16 16:19:09 -0400503#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2)
Li Zefana6fa6fa2010-10-25 15:12:26 +0800504#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3)
Chris Mason727011e2010-08-06 13:21:20 -0400505/*
506 * some patches floated around with a second compression method
507 * lets save that incompat here for when they do get in
508 * Note we don't actually support it, we're just reserving the
509 * number
510 */
511#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2 (1ULL << 4)
512
513/*
514 * older kernels tried to do bigger metadata blocks, but the
515 * code was pretty buggy. Lets not let them try anymore.
516 */
517#define BTRFS_FEATURE_INCOMPAT_BIG_METADATA (1ULL << 5)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400518
Mark Fashehf1863732012-08-08 11:32:27 -0700519#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF (1ULL << 6)
David Woodhouse53b381b2013-01-29 18:40:14 -0500520#define BTRFS_FEATURE_INCOMPAT_RAID56 (1ULL << 7)
Josef Bacik3173a182013-03-07 14:22:04 -0500521#define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA (1ULL << 8)
Josef Bacik16e75492013-10-22 12:18:51 -0400522#define BTRFS_FEATURE_INCOMPAT_NO_HOLES (1ULL << 9)
Mark Fashehf1863732012-08-08 11:32:27 -0700523
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400524#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500525#define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL
526#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400527#define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500528#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL
529#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL
530
Josef Bacik0af3d002010-06-21 14:48:16 -0400531#define BTRFS_FEATURE_INCOMPAT_SUPP \
532 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
Josef Bacik67377732010-09-16 16:19:09 -0400533 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
Li Zefana6fa6fa2010-10-25 15:12:26 +0800534 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
Chris Mason727011e2010-08-06 13:21:20 -0400535 BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \
Mark Fashehf1863732012-08-08 11:32:27 -0700536 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \
David Woodhouse53b381b2013-01-29 18:40:14 -0500537 BTRFS_FEATURE_INCOMPAT_RAID56 | \
Josef Bacik3173a182013-03-07 14:22:04 -0500538 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \
Josef Bacik16e75492013-10-22 12:18:51 -0400539 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \
540 BTRFS_FEATURE_INCOMPAT_NO_HOLES)
Josef Bacikf2b636e2008-12-02 06:36:08 -0500541
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500542#define BTRFS_FEATURE_INCOMPAT_SAFE_SET \
543 (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
544#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL
Josef Bacikf2b636e2008-12-02 06:36:08 -0500545
546/*
Chris Mason62e27492007-03-15 12:56:47 -0400547 * A leaf is full of items. offset and size tell us where to find
Chris Masonfec577f2007-02-26 10:40:21 -0500548 * the item in the leaf (relative to the start of the data area)
549 */
Chris Mason0783fcf2007-03-12 20:12:07 -0400550struct btrfs_item {
Chris Masone2fa7222007-03-12 16:22:34 -0400551 struct btrfs_disk_key key;
Chris Mason123abc82007-03-14 14:14:43 -0400552 __le32 offset;
Chris Mason5f39d392007-10-15 16:14:19 -0400553 __le32 size;
Chris Masoneb60cea2007-02-02 09:18:22 -0500554} __attribute__ ((__packed__));
555
Chris Masonfec577f2007-02-26 10:40:21 -0500556/*
557 * leaves have an item area and a data area:
558 * [item0, item1....itemN] [free space] [dataN...data1, data0]
559 *
560 * The data is separate from the items to get the keys closer together
561 * during searches.
562 */
Chris Mason234b63a2007-03-13 10:46:10 -0400563struct btrfs_leaf {
Chris Masonbb492bb2007-03-12 12:29:44 -0400564 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400565 struct btrfs_item items[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500566} __attribute__ ((__packed__));
567
Chris Masonfec577f2007-02-26 10:40:21 -0500568/*
569 * all non-leaf blocks are nodes, they hold only keys and pointers to
570 * other blocks
571 */
Chris Mason123abc82007-03-14 14:14:43 -0400572struct btrfs_key_ptr {
573 struct btrfs_disk_key key;
574 __le64 blockptr;
Chris Mason74493f72007-12-11 09:25:06 -0500575 __le64 generation;
Chris Mason123abc82007-03-14 14:14:43 -0400576} __attribute__ ((__packed__));
577
Chris Mason234b63a2007-03-13 10:46:10 -0400578struct btrfs_node {
Chris Masonbb492bb2007-03-12 12:29:44 -0400579 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400580 struct btrfs_key_ptr ptrs[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500581} __attribute__ ((__packed__));
582
Chris Masonfec577f2007-02-26 10:40:21 -0500583/*
Chris Mason234b63a2007-03-13 10:46:10 -0400584 * btrfs_paths remember the path taken from the root down to the leaf.
585 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
Chris Masonfec577f2007-02-26 10:40:21 -0500586 * to any other levels that are present.
587 *
588 * The slots array records the index of the item or block pointer
589 * used while walking the tree.
590 */
Chris Mason234b63a2007-03-13 10:46:10 -0400591struct btrfs_path {
Chris Mason5f39d392007-10-15 16:14:19 -0400592 struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
Chris Mason234b63a2007-03-13 10:46:10 -0400593 int slots[BTRFS_MAX_LEVEL];
Chris Mason925baed2008-06-25 16:01:30 -0400594 /* if there is real range locking, this locks field will change */
595 int locks[BTRFS_MAX_LEVEL];
Chris Mason3c69fae2007-08-07 15:52:22 -0400596 int reada;
Chris Mason925baed2008-06-25 16:01:30 -0400597 /* keep some upper locks as we walk down */
Chris Mason6702ed42007-08-07 16:15:09 -0400598 int lowest_level;
Chris Mason459931e2008-12-10 09:10:46 -0500599
600 /*
601 * set by btrfs_split_item, tells search_slot to keep all locks
602 * and to force calls to keep space in the nodes
603 */
Chris Masonb9473432009-03-13 11:00:37 -0400604 unsigned int search_for_split:1;
605 unsigned int keep_locks:1;
606 unsigned int skip_locking:1;
607 unsigned int leave_spinning:1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400608 unsigned int search_commit_root:1;
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400609 unsigned int need_commit_sem:1;
Filipe Manana5f5bc6b2014-11-09 08:38:39 +0000610 unsigned int skip_release_on_error:1;
Chris Masoneb60cea2007-02-02 09:18:22 -0500611};
Chris Mason5de08d72007-02-24 06:24:44 -0500612
Chris Mason62e27492007-03-15 12:56:47 -0400613/*
614 * items in the extent btree are used to record the objectid of the
615 * owner of the block and the number of references
616 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400617
Chris Mason62e27492007-03-15 12:56:47 -0400618struct btrfs_extent_item {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400619 __le64 refs;
620 __le64 generation;
621 __le64 flags;
622} __attribute__ ((__packed__));
623
624struct btrfs_extent_item_v0 {
Chris Mason62e27492007-03-15 12:56:47 -0400625 __le32 refs;
Chris Mason74493f72007-12-11 09:25:06 -0500626} __attribute__ ((__packed__));
627
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400628#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
629 sizeof(struct btrfs_item))
630
631#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
632#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
633
634/* following flags only apply to tree blocks */
635
636/* use full backrefs for extent pointers in the block */
637#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
638
Arne Jansena2de7332011-03-08 14:14:00 +0100639/*
640 * this flag is only used internally by scrub and may be changed at any time
641 * it is only declared here to avoid collisions
642 */
643#define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)
644
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400645struct btrfs_tree_block_info {
646 struct btrfs_disk_key key;
647 u8 level;
648} __attribute__ ((__packed__));
649
650struct btrfs_extent_data_ref {
651 __le64 root;
652 __le64 objectid;
653 __le64 offset;
654 __le32 count;
655} __attribute__ ((__packed__));
656
657struct btrfs_shared_data_ref {
658 __le32 count;
659} __attribute__ ((__packed__));
660
661struct btrfs_extent_inline_ref {
662 u8 type;
Yan Zheng1bec1ae2009-07-22 09:59:00 -0400663 __le64 offset;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400664} __attribute__ ((__packed__));
665
666/* old style backrefs item */
667struct btrfs_extent_ref_v0 {
Chris Mason74493f72007-12-11 09:25:06 -0500668 __le64 root;
669 __le64 generation;
670 __le64 objectid;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400671 __le32 count;
Chris Mason62e27492007-03-15 12:56:47 -0400672} __attribute__ ((__packed__));
673
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400674
Chris Mason0b86a832008-03-24 15:01:56 -0400675/* dev extents record free space on individual devices. The owner
676 * field points back to the chunk allocation mapping tree that allocated
Chris Masone17cade2008-04-15 15:41:47 -0400677 * the extent. The chunk tree uuid field is a way to double check the owner
Chris Mason0b86a832008-03-24 15:01:56 -0400678 */
679struct btrfs_dev_extent {
Chris Masone17cade2008-04-15 15:41:47 -0400680 __le64 chunk_tree;
681 __le64 chunk_objectid;
682 __le64 chunk_offset;
Chris Mason0b86a832008-03-24 15:01:56 -0400683 __le64 length;
Chris Masone17cade2008-04-15 15:41:47 -0400684 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400685} __attribute__ ((__packed__));
686
Chris Mason39544012007-12-12 14:38:19 -0500687struct btrfs_inode_ref {
Josef Bacikaec74772008-07-24 12:12:38 -0400688 __le64 index;
Chris Mason39544012007-12-12 14:38:19 -0500689 __le16 name_len;
690 /* name goes here */
691} __attribute__ ((__packed__));
692
Mark Fashehf1863732012-08-08 11:32:27 -0700693struct btrfs_inode_extref {
694 __le64 parent_objectid;
695 __le64 index;
696 __le16 name_len;
697 __u8 name[0];
698 /* name goes here */
699} __attribute__ ((__packed__));
700
Chris Mason0b86a832008-03-24 15:01:56 -0400701struct btrfs_timespec {
Chris Masonf254e522007-03-29 15:15:27 -0400702 __le64 sec;
Chris Mason1e1d2702007-03-15 19:03:33 -0400703 __le32 nsec;
704} __attribute__ ((__packed__));
705
Jan Engelhardt95029d72009-01-21 10:49:16 -0500706enum btrfs_compression_type {
Li Zefan261507a02010-12-17 14:21:50 +0800707 BTRFS_COMPRESS_NONE = 0,
708 BTRFS_COMPRESS_ZLIB = 1,
Li Zefana6fa6fa2010-10-25 15:12:26 +0800709 BTRFS_COMPRESS_LZO = 2,
710 BTRFS_COMPRESS_TYPES = 2,
711 BTRFS_COMPRESS_LAST = 3,
Jan Engelhardt95029d72009-01-21 10:49:16 -0500712};
Chris Masonc8b97812008-10-29 14:49:59 -0400713
Chris Mason1e1d2702007-03-15 19:03:33 -0400714struct btrfs_inode_item {
Chris Masone02119d2008-09-05 16:13:11 -0400715 /* nfs style generation number */
Chris Mason1e1d2702007-03-15 19:03:33 -0400716 __le64 generation;
Chris Masone02119d2008-09-05 16:13:11 -0400717 /* transid that last touched this inode */
718 __le64 transid;
Chris Mason1e1d2702007-03-15 19:03:33 -0400719 __le64 size;
Yan Zhenga76a3cd2008-10-09 11:46:29 -0400720 __le64 nbytes;
Chris Mason31f3c992007-04-30 15:25:45 -0400721 __le64 block_group;
Chris Mason1e1d2702007-03-15 19:03:33 -0400722 __le32 nlink;
723 __le32 uid;
724 __le32 gid;
725 __le32 mode;
Chris Mason0b86a832008-03-24 15:01:56 -0400726 __le64 rdev;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500727 __le64 flags;
Chris Masonc8b97812008-10-29 14:49:59 -0400728
Chris Masonc3027eb2008-12-08 16:40:21 -0500729 /* modification sequence number for NFS */
730 __le64 sequence;
731
732 /*
733 * a little future expansion, for more than this we can
734 * just grow the inode item and version it
735 */
736 __le64 reserved[4];
Chris Mason0b86a832008-03-24 15:01:56 -0400737 struct btrfs_timespec atime;
738 struct btrfs_timespec ctime;
739 struct btrfs_timespec mtime;
740 struct btrfs_timespec otime;
Chris Mason1e1d2702007-03-15 19:03:33 -0400741} __attribute__ ((__packed__));
742
Chris Masone02119d2008-09-05 16:13:11 -0400743struct btrfs_dir_log_item {
744 __le64 end;
745} __attribute__ ((__packed__));
746
Chris Mason62e27492007-03-15 12:56:47 -0400747struct btrfs_dir_item {
Chris Masond6e4a422007-04-06 15:37:36 -0400748 struct btrfs_disk_key location;
Chris Masone02119d2008-09-05 16:13:11 -0400749 __le64 transid;
Josef Bacik5103e942007-11-16 11:45:54 -0500750 __le16 data_len;
Chris Masona8a2ee02007-03-16 08:46:49 -0400751 __le16 name_len;
Chris Mason62e27492007-03-15 12:56:47 -0400752 u8 type;
753} __attribute__ ((__packed__));
754
Li Zefanb83cc962010-12-20 16:04:08 +0800755#define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)
756
David Sterba521e0542014-04-15 16:41:44 +0200757/*
758 * Internal in-memory flag that a subvolume has been marked for deletion but
759 * still visible as a directory
760 */
761#define BTRFS_ROOT_SUBVOL_DEAD (1ULL << 48)
762
Chris Mason62e27492007-03-15 12:56:47 -0400763struct btrfs_root_item {
Chris Masond6e4a422007-04-06 15:37:36 -0400764 struct btrfs_inode_item inode;
Yan Zheng84234f32008-10-29 14:49:05 -0400765 __le64 generation;
Chris Masond6e4a422007-04-06 15:37:36 -0400766 __le64 root_dirid;
Chris Masondb945352007-10-15 16:15:53 -0400767 __le64 bytenr;
768 __le64 byte_limit;
769 __le64 bytes_used;
Yan Zheng80ff3852008-10-30 14:20:02 -0400770 __le64 last_snapshot;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500771 __le64 flags;
Chris Mason62e27492007-03-15 12:56:47 -0400772 __le32 refs;
Chris Mason5eda7b52007-06-22 14:16:25 -0400773 struct btrfs_disk_key drop_progress;
774 u8 drop_level;
Chris Masondb945352007-10-15 16:15:53 -0400775 u8 level;
Alexander Block8ea05e32012-07-25 17:35:53 +0200776
777 /*
778 * The following fields appear after subvol_uuids+subvol_times
779 * were introduced.
780 */
781
782 /*
783 * This generation number is used to test if the new fields are valid
784 * and up to date while reading the root item. Everytime the root item
785 * is written out, the "generation" field is copied into this field. If
786 * anyone ever mounted the fs with an older kernel, we will have
787 * mismatching generation values here and thus must invalidate the
788 * new fields. See btrfs_update_root and btrfs_find_last_root for
789 * details.
790 * the offset of generation_v2 is also used as the start for the memset
791 * when invalidating the fields.
792 */
793 __le64 generation_v2;
794 u8 uuid[BTRFS_UUID_SIZE];
795 u8 parent_uuid[BTRFS_UUID_SIZE];
796 u8 received_uuid[BTRFS_UUID_SIZE];
797 __le64 ctransid; /* updated when an inode changes */
798 __le64 otransid; /* trans when created */
799 __le64 stransid; /* trans when sent. non-zero for received subvol */
800 __le64 rtransid; /* trans when received. non-zero for received subvol */
801 struct btrfs_timespec ctime;
802 struct btrfs_timespec otime;
803 struct btrfs_timespec stime;
804 struct btrfs_timespec rtime;
805 __le64 reserved[8]; /* for future */
Chris Mason9f5fae22007-03-20 14:38:32 -0400806} __attribute__ ((__packed__));
807
Chris Mason0660b5a2008-11-17 20:37:39 -0500808/*
809 * this is used for both forward and backward root refs
810 */
811struct btrfs_root_ref {
812 __le64 dirid;
813 __le64 sequence;
814 __le16 name_len;
815} __attribute__ ((__packed__));
816
Ilya Dryomov0940ebf2012-01-16 22:04:48 +0200817struct btrfs_disk_balance_args {
818 /*
819 * profiles to operate on, single is denoted by
820 * BTRFS_AVAIL_ALLOC_BIT_SINGLE
821 */
822 __le64 profiles;
823
824 /* usage filter */
825 __le64 usage;
826
827 /* devid filter */
828 __le64 devid;
829
830 /* devid subset filter [pstart..pend) */
831 __le64 pstart;
832 __le64 pend;
833
834 /* btrfs virtual address space subset filter [vstart..vend) */
835 __le64 vstart;
836 __le64 vend;
837
838 /*
839 * profile to convert to, single is denoted by
840 * BTRFS_AVAIL_ALLOC_BIT_SINGLE
841 */
842 __le64 target;
843
844 /* BTRFS_BALANCE_ARGS_* */
845 __le64 flags;
846
David Sterba7d824b62014-05-07 17:37:51 +0200847 /* BTRFS_BALANCE_ARGS_LIMIT value */
848 __le64 limit;
849
850 __le64 unused[7];
Ilya Dryomov0940ebf2012-01-16 22:04:48 +0200851} __attribute__ ((__packed__));
852
853/*
854 * store balance parameters to disk so that balance can be properly
855 * resumed after crash or unmount
856 */
857struct btrfs_balance_item {
858 /* BTRFS_BALANCE_* */
859 __le64 flags;
860
861 struct btrfs_disk_balance_args data;
862 struct btrfs_disk_balance_args meta;
863 struct btrfs_disk_balance_args sys;
864
865 __le64 unused[4];
866} __attribute__ ((__packed__));
867
Yan Zhengd899e052008-10-30 14:25:28 -0400868#define BTRFS_FILE_EXTENT_INLINE 0
869#define BTRFS_FILE_EXTENT_REG 1
870#define BTRFS_FILE_EXTENT_PREALLOC 2
Chris Mason236454d2007-04-19 13:37:44 -0400871
Chris Mason9f5fae22007-03-20 14:38:32 -0400872struct btrfs_file_extent_item {
Chris Masonc8b97812008-10-29 14:49:59 -0400873 /*
874 * transaction id that created this extent
875 */
Chris Mason71951f32007-03-27 09:16:29 -0400876 __le64 generation;
Chris Masonc8b97812008-10-29 14:49:59 -0400877 /*
878 * max number of bytes to hold this extent in ram
879 * when we split a compressed extent we can't know how big
880 * each of the resulting pieces will be. So, this is
881 * an upper limit on the size of the extent in ram instead of
882 * an exact limit.
883 */
884 __le64 ram_bytes;
885
886 /*
887 * 32 bits for the various ways we might encode the data,
888 * including compression and encryption. If any of these
889 * are set to something a given disk format doesn't understand
890 * it is treated like an incompat flag for reading and writing,
891 * but not for stat.
892 */
893 u8 compression;
894 u8 encryption;
895 __le16 other_encoding; /* spare for later use */
896
897 /* are we inline data or a real extent? */
Chris Mason236454d2007-04-19 13:37:44 -0400898 u8 type;
Chris Masonc8b97812008-10-29 14:49:59 -0400899
Chris Mason9f5fae22007-03-20 14:38:32 -0400900 /*
901 * disk space consumed by the extent, checksum blocks are included
902 * in these numbers
David Sterba7ec20af2014-07-24 17:34:58 +0200903 *
904 * At this offset in the structure, the inline extent data start.
Chris Mason9f5fae22007-03-20 14:38:32 -0400905 */
Chris Masondb945352007-10-15 16:15:53 -0400906 __le64 disk_bytenr;
907 __le64 disk_num_bytes;
Chris Mason9f5fae22007-03-20 14:38:32 -0400908 /*
Chris Masondee26a92007-03-26 16:00:06 -0400909 * the logical offset in file blocks (no csums)
Chris Mason9f5fae22007-03-20 14:38:32 -0400910 * this extent record is for. This allows a file extent to point
911 * into the middle of an existing extent on disk, sharing it
912 * between two snapshots (useful if some bytes in the middle of the
913 * extent have changed
914 */
915 __le64 offset;
916 /*
Chris Masonc8b97812008-10-29 14:49:59 -0400917 * the logical number of file blocks (no csums included). This
918 * always reflects the size uncompressed and without encoding.
Chris Mason9f5fae22007-03-20 14:38:32 -0400919 */
Chris Masondb945352007-10-15 16:15:53 -0400920 __le64 num_bytes;
Chris Masonc8b97812008-10-29 14:49:59 -0400921
Chris Mason9f5fae22007-03-20 14:38:32 -0400922} __attribute__ ((__packed__));
923
Chris Masonf254e522007-03-29 15:15:27 -0400924struct btrfs_csum_item {
Chris Mason509659c2007-05-10 12:36:17 -0400925 u8 csum;
Chris Masonf254e522007-03-29 15:15:27 -0400926} __attribute__ ((__packed__));
927
Stefan Behrens733f4fb2012-05-25 16:06:10 +0200928struct btrfs_dev_stats_item {
929 /*
930 * grow this item struct at the end for future enhancements and keep
931 * the existing values unchanged
932 */
933 __le64 values[BTRFS_DEV_STAT_VALUES_MAX];
934} __attribute__ ((__packed__));
935
Stefan Behrense922e082012-11-05 17:26:40 +0100936#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 0
937#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID 1
938#define BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED 0
939#define BTRFS_DEV_REPLACE_ITEM_STATE_STARTED 1
940#define BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED 2
941#define BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED 3
942#define BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED 4
943
944struct btrfs_dev_replace {
945 u64 replace_state; /* see #define above */
946 u64 time_started; /* seconds since 1-Jan-1970 */
947 u64 time_stopped; /* seconds since 1-Jan-1970 */
948 atomic64_t num_write_errors;
949 atomic64_t num_uncorrectable_read_errors;
950
951 u64 cursor_left;
952 u64 committed_cursor_left;
953 u64 cursor_left_last_write_of_item;
954 u64 cursor_right;
955
956 u64 cont_reading_from_srcdev_mode; /* see #define above */
957
958 int is_valid;
959 int item_needs_writeback;
960 struct btrfs_device *srcdev;
961 struct btrfs_device *tgtdev;
962
963 pid_t lock_owner;
964 atomic_t nesting_level;
965 struct mutex lock_finishing_cancel_unmount;
966 struct mutex lock_management_lock;
967 struct mutex lock;
968
969 struct btrfs_scrub_progress scrub_progress;
970};
971
Stefan Behrensa2bff642012-11-05 17:32:20 +0100972struct btrfs_dev_replace_item {
973 /*
974 * grow this item struct at the end for future enhancements and keep
975 * the existing values unchanged
976 */
977 __le64 src_devid;
978 __le64 cursor_left;
979 __le64 cursor_right;
980 __le64 cont_reading_from_srcdev_mode;
981
982 __le64 replace_state;
983 __le64 time_started;
984 __le64 time_stopped;
985 __le64 num_write_errors;
986 __le64 num_uncorrectable_read_errors;
987} __attribute__ ((__packed__));
988
Chris Mason0b86a832008-03-24 15:01:56 -0400989/* different types of block groups (and chunks) */
Ilya Dryomov52ba6922012-01-16 22:04:47 +0200990#define BTRFS_BLOCK_GROUP_DATA (1ULL << 0)
991#define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1)
992#define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2)
993#define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3)
994#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)
995#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)
996#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
Andreas Philipp1c89cdd2013-05-11 11:12:54 +0000997#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)
998#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)
David Sterba36523e952014-02-07 14:34:12 +0100999#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \
1000 BTRFS_SPACE_INFO_GLOBAL_RSV)
Miao Xiee6ec7162013-01-17 05:38:51 +00001001
1002enum btrfs_raid_types {
1003 BTRFS_RAID_RAID10,
1004 BTRFS_RAID_RAID1,
1005 BTRFS_RAID_DUP,
1006 BTRFS_RAID_RAID0,
1007 BTRFS_RAID_SINGLE,
Chris Masone942f882013-02-20 14:06:05 -05001008 BTRFS_RAID_RAID5,
1009 BTRFS_RAID_RAID6,
Miao Xiee6ec7162013-01-17 05:38:51 +00001010 BTRFS_NR_RAID_TYPES
1011};
Chris Mason1e2677e2007-05-29 16:52:18 -04001012
Ilya Dryomov52ba6922012-01-16 22:04:47 +02001013#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \
1014 BTRFS_BLOCK_GROUP_SYSTEM | \
1015 BTRFS_BLOCK_GROUP_METADATA)
1016
1017#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \
1018 BTRFS_BLOCK_GROUP_RAID1 | \
David Woodhouse53b381b2013-01-29 18:40:14 -05001019 BTRFS_BLOCK_GROUP_RAID5 | \
1020 BTRFS_BLOCK_GROUP_RAID6 | \
Ilya Dryomov52ba6922012-01-16 22:04:47 +02001021 BTRFS_BLOCK_GROUP_DUP | \
1022 BTRFS_BLOCK_GROUP_RAID10)
Ilya Dryomova46d11a2012-01-16 22:04:47 +02001023/*
1024 * We need a bit for restriper to be able to tell when chunks of type
1025 * SINGLE are available. This "extended" profile format is used in
1026 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields
1027 * (on-disk). The corresponding on-disk bit in chunk.type is reserved
1028 * to avoid remappings between two formats in future.
1029 */
1030#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)
1031
David Sterba36523e952014-02-07 14:34:12 +01001032/*
1033 * A fake block group type that is used to communicate global block reserve
1034 * size to userspace via the SPACE_INFO ioctl.
1035 */
1036#define BTRFS_SPACE_INFO_GLOBAL_RSV (1ULL << 49)
1037
Ilya Dryomov899c81e2012-03-27 17:09:16 +03001038#define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK | \
1039 BTRFS_AVAIL_ALLOC_BIT_SINGLE)
1040
1041static inline u64 chunk_to_extended(u64 flags)
1042{
1043 if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)
1044 flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1045
1046 return flags;
1047}
1048static inline u64 extended_to_chunk(u64 flags)
1049{
1050 return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
1051}
1052
Chris Mason9078a3e2007-04-26 16:46:15 -04001053struct btrfs_block_group_item {
1054 __le64 used;
Chris Mason0b86a832008-03-24 15:01:56 -04001055 __le64 chunk_objectid;
1056 __le64 flags;
Chris Mason9078a3e2007-04-26 16:46:15 -04001057} __attribute__ ((__packed__));
1058
Arne Jansen630dc772011-09-13 11:06:07 +02001059/*
1060 * is subvolume quota turned on?
1061 */
1062#define BTRFS_QGROUP_STATUS_FLAG_ON (1ULL << 0)
1063/*
Jan Schmidt2f232032013-04-25 16:04:51 +00001064 * RESCAN is set during the initialization phase
Arne Jansen630dc772011-09-13 11:06:07 +02001065 */
Jan Schmidt2f232032013-04-25 16:04:51 +00001066#define BTRFS_QGROUP_STATUS_FLAG_RESCAN (1ULL << 1)
Arne Jansen630dc772011-09-13 11:06:07 +02001067/*
1068 * Some qgroup entries are known to be out of date,
1069 * either because the configuration has changed in a way that
1070 * makes a rescan necessary, or because the fs has been mounted
1071 * with a non-qgroup-aware version.
1072 * Turning qouta off and on again makes it inconsistent, too.
1073 */
1074#define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT (1ULL << 2)
1075
1076#define BTRFS_QGROUP_STATUS_VERSION 1
1077
1078struct btrfs_qgroup_status_item {
1079 __le64 version;
1080 /*
1081 * the generation is updated during every commit. As older
1082 * versions of btrfs are not aware of qgroups, it will be
1083 * possible to detect inconsistencies by checking the
1084 * generation on mount time
1085 */
1086 __le64 generation;
1087
1088 /* flag definitions see above */
1089 __le64 flags;
1090
1091 /*
1092 * only used during scanning to record the progress
1093 * of the scan. It contains a logical address
1094 */
Jan Schmidt2f232032013-04-25 16:04:51 +00001095 __le64 rescan;
Arne Jansen630dc772011-09-13 11:06:07 +02001096} __attribute__ ((__packed__));
1097
1098struct btrfs_qgroup_info_item {
1099 __le64 generation;
1100 __le64 rfer;
1101 __le64 rfer_cmpr;
1102 __le64 excl;
1103 __le64 excl_cmpr;
1104} __attribute__ ((__packed__));
1105
1106/* flags definition for qgroup limits */
1107#define BTRFS_QGROUP_LIMIT_MAX_RFER (1ULL << 0)
1108#define BTRFS_QGROUP_LIMIT_MAX_EXCL (1ULL << 1)
1109#define BTRFS_QGROUP_LIMIT_RSV_RFER (1ULL << 2)
1110#define BTRFS_QGROUP_LIMIT_RSV_EXCL (1ULL << 3)
1111#define BTRFS_QGROUP_LIMIT_RFER_CMPR (1ULL << 4)
1112#define BTRFS_QGROUP_LIMIT_EXCL_CMPR (1ULL << 5)
1113
1114struct btrfs_qgroup_limit_item {
1115 /*
1116 * only updated when any of the other values change
1117 */
1118 __le64 flags;
1119 __le64 max_rfer;
1120 __le64 max_excl;
1121 __le64 rsv_rfer;
1122 __le64 rsv_excl;
1123} __attribute__ ((__packed__));
1124
Jeff Mahoneyc1895442014-05-27 12:59:57 -04001125/* For raid type sysfs entries */
1126struct raid_kobject {
1127 int raid_type;
1128 struct kobject kobj;
1129};
1130
Chris Mason6324fbf2008-03-24 15:01:59 -04001131struct btrfs_space_info {
Miao Xie26b47ff2014-01-15 20:00:54 +08001132 spinlock_t lock;
Josef Bacik6a632092009-02-20 11:00:09 -05001133
Josef Bacik89a55892010-10-14 14:52:27 -04001134 u64 total_bytes; /* total bytes in the space,
1135 this doesn't take mirrors into account */
Yan, Zhengb742bb82010-05-16 10:46:24 -04001136 u64 bytes_used; /* total bytes used,
Lucas De Marchie9c54992011-04-26 23:28:26 -07001137 this doesn't take mirrors into account */
Josef Bacik6a632092009-02-20 11:00:09 -05001138 u64 bytes_pinned; /* total bytes pinned, will be freed when the
1139 transaction finishes */
1140 u64 bytes_reserved; /* total bytes the allocator has reserved for
1141 current allocations */
Josef Bacik6a632092009-02-20 11:00:09 -05001142 u64 bytes_may_use; /* number of bytes that may be used for
Josef Bacik9ed74f22009-09-11 16:12:44 -04001143 delalloc/allocations */
Miao Xie26b47ff2014-01-15 20:00:54 +08001144 u64 bytes_readonly; /* total bytes that are read only */
1145
1146 unsigned int full:1; /* indicates that we cannot allocate any more
1147 chunks for this space */
1148 unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
1149
1150 unsigned int flush:1; /* set if we are trying to make space */
1151
1152 unsigned int force_alloc; /* set if we need to force a chunk
1153 alloc for this space */
1154
Yan, Zhengb742bb82010-05-16 10:46:24 -04001155 u64 disk_used; /* total bytes used on disk */
Josef Bacik89a55892010-10-14 14:52:27 -04001156 u64 disk_total; /* total bytes on disk, takes mirrors into
1157 account */
Josef Bacik6a632092009-02-20 11:00:09 -05001158
Miao Xie26b47ff2014-01-15 20:00:54 +08001159 u64 flags;
1160
Chris Mason36e39c42011-03-12 07:08:42 -05001161 /*
Josef Bacikb150a4f2013-06-19 15:00:04 -04001162 * bytes_pinned is kept in line with what is actually pinned, as in
1163 * we've called update_block_group and dropped the bytes_used counter
1164 * and increased the bytes_pinned counter. However this means that
1165 * bytes_pinned does not reflect the bytes that will be pinned once the
1166 * delayed refs are flushed, so this counter is inc'ed everytime we call
1167 * btrfs_free_extent so it is a realtime count of what will be freed
1168 * once the transaction is committed. It will be zero'ed everytime the
1169 * transaction commits.
1170 */
1171 struct percpu_counter total_bytes_pinned;
1172
Chris Mason6324fbf2008-03-24 15:01:59 -04001173 struct list_head list;
Filipe Manana75c68e92015-01-16 13:24:40 +00001174 /* Protected by the spinlock 'lock'. */
Josef Bacik633c0aa2014-10-31 09:49:34 -04001175 struct list_head ro_bgs;
Josef Bacik0f9dd462008-09-23 13:14:11 -04001176
Miao Xie26b47ff2014-01-15 20:00:54 +08001177 struct rw_semaphore groups_sem;
Josef Bacik0f9dd462008-09-23 13:14:11 -04001178 /* for block groups in our same type */
Yan, Zhengb742bb82010-05-16 10:46:24 -04001179 struct list_head block_groups[BTRFS_NR_RAID_TYPES];
Josef Bacikfdb5eff2011-06-07 16:07:44 -04001180 wait_queue_head_t wait;
Jeff Mahoney6ab0a202013-11-01 13:07:04 -04001181
1182 struct kobject kobj;
Jeff Mahoneyc1895442014-05-27 12:59:57 -04001183 struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
Josef Bacik0f9dd462008-09-23 13:14:11 -04001184};
1185
Miao Xie66d8f3d2012-09-06 04:02:28 -06001186#define BTRFS_BLOCK_RSV_GLOBAL 1
1187#define BTRFS_BLOCK_RSV_DELALLOC 2
1188#define BTRFS_BLOCK_RSV_TRANS 3
1189#define BTRFS_BLOCK_RSV_CHUNK 4
1190#define BTRFS_BLOCK_RSV_DELOPS 5
1191#define BTRFS_BLOCK_RSV_EMPTY 6
1192#define BTRFS_BLOCK_RSV_TEMP 7
1193
Yan, Zhengf0486c62010-05-16 10:46:25 -04001194struct btrfs_block_rsv {
1195 u64 size;
1196 u64 reserved;
Yan, Zhengf0486c62010-05-16 10:46:25 -04001197 struct btrfs_space_info *space_info;
Yan, Zhengf0486c62010-05-16 10:46:25 -04001198 spinlock_t lock;
Miao Xie66d8f3d2012-09-06 04:02:28 -06001199 unsigned short full;
1200 unsigned short type;
1201 unsigned short failfast;
Yan, Zhengf0486c62010-05-16 10:46:25 -04001202};
1203
Chris Masonfa9c0d792009-04-03 09:47:43 -04001204/*
1205 * free clusters are used to claim free space in relatively large chunks,
1206 * allowing us to do less seeky writes. They are used for all metadata
1207 * allocations and data allocations in ssd mode.
1208 */
1209struct btrfs_free_cluster {
1210 spinlock_t lock;
1211 spinlock_t refill_lock;
1212 struct rb_root root;
1213
1214 /* largest extent in this cluster */
1215 u64 max_size;
1216
1217 /* first extent starting offset */
1218 u64 window_start;
1219
1220 struct btrfs_block_group_cache *block_group;
1221 /*
1222 * when a cluster is allocated from a block group, we put the
1223 * cluster onto a list in the block group so that it can
1224 * be freed before the block group is freed.
1225 */
1226 struct list_head block_group_list;
Chris Mason6324fbf2008-03-24 15:01:59 -04001227};
1228
Josef Bacik817d52f2009-07-13 21:29:25 -04001229enum btrfs_caching_type {
1230 BTRFS_CACHE_NO = 0,
1231 BTRFS_CACHE_STARTED = 1,
Josef Bacik291c7d22011-11-14 13:52:14 -05001232 BTRFS_CACHE_FAST = 2,
1233 BTRFS_CACHE_FINISHED = 3,
Josef Bacik36cce922013-08-05 11:15:21 -04001234 BTRFS_CACHE_ERROR = 4,
Josef Bacik817d52f2009-07-13 21:29:25 -04001235};
1236
Josef Bacik0af3d002010-06-21 14:48:16 -04001237enum btrfs_disk_cache_state {
1238 BTRFS_DC_WRITTEN = 0,
1239 BTRFS_DC_ERROR = 1,
1240 BTRFS_DC_CLEAR = 2,
1241 BTRFS_DC_SETUP = 3,
1242 BTRFS_DC_NEED_WRITE = 4,
1243};
1244
Yan Zheng11833d62009-09-11 16:11:19 -04001245struct btrfs_caching_control {
1246 struct list_head list;
1247 struct mutex mutex;
1248 wait_queue_head_t wait;
Josef Bacikbab39bf2011-06-30 14:42:28 -04001249 struct btrfs_work work;
Yan Zheng11833d62009-09-11 16:11:19 -04001250 struct btrfs_block_group_cache *block_group;
1251 u64 progress;
1252 atomic_t count;
1253};
1254
Chris Mason9078a3e2007-04-26 16:46:15 -04001255struct btrfs_block_group_cache {
1256 struct btrfs_key key;
1257 struct btrfs_block_group_item item;
Josef Bacik817d52f2009-07-13 21:29:25 -04001258 struct btrfs_fs_info *fs_info;
Josef Bacik0af3d002010-06-21 14:48:16 -04001259 struct inode *inode;
Chris Masonc286ac42008-07-22 23:06:41 -04001260 spinlock_t lock;
Yan324ae4d2007-11-16 14:57:08 -05001261 u64 pinned;
Zheng Yane8569812008-09-26 10:05:48 -04001262 u64 reserved;
Miao Xiee570fd22014-06-19 10:42:50 +08001263 u64 delalloc_bytes;
Josef Bacik1b2da372009-09-11 16:11:20 -04001264 u64 bytes_super;
Chris Mason0b86a832008-03-24 15:01:56 -04001265 u64 flags;
Josef Bacik96303082009-07-13 21:29:25 -04001266 u64 sectorsize;
Josef Bacik5b0e95b2011-10-06 08:58:24 -04001267 u64 cache_generation;
David Woodhouse53b381b2013-01-29 18:40:14 -05001268
Miao Xiee570fd22014-06-19 10:42:50 +08001269 /*
1270 * It is just used for the delayed data space allocation because
1271 * only the data space allocation and the relative metadata update
1272 * can be done cross the transaction.
1273 */
1274 struct rw_semaphore data_rwsem;
1275
David Woodhouse53b381b2013-01-29 18:40:14 -05001276 /* for raid56, this is a full stripe, without parity */
1277 unsigned long full_stripe_len;
1278
Mariusz Kozlowski0410c942010-11-20 12:03:07 +00001279 unsigned int ro:1;
1280 unsigned int dirty:1;
1281 unsigned int iref:1;
Filipe Manana4f69cb92014-11-26 15:28:51 +00001282 unsigned int has_caching_ctl:1;
Filipe Manana04216822014-11-27 21:14:15 +00001283 unsigned int removed:1;
Josef Bacik0af3d002010-06-21 14:48:16 -04001284
1285 int disk_cache_state;
Josef Bacik0f9dd462008-09-23 13:14:11 -04001286
Josef Bacik817d52f2009-07-13 21:29:25 -04001287 /* cache tracking stuff */
Josef Bacik817d52f2009-07-13 21:29:25 -04001288 int cached;
Yan Zheng11833d62009-09-11 16:11:19 -04001289 struct btrfs_caching_control *caching_ctl;
1290 u64 last_byte_to_unpin;
Josef Bacik817d52f2009-07-13 21:29:25 -04001291
Josef Bacik0f9dd462008-09-23 13:14:11 -04001292 struct btrfs_space_info *space_info;
1293
1294 /* free space cache stuff */
Li Zefan34d52cb2011-03-29 13:46:06 +08001295 struct btrfs_free_space_ctl *free_space_ctl;
Josef Bacik0f9dd462008-09-23 13:14:11 -04001296
1297 /* block group cache stuff */
1298 struct rb_node cache_node;
1299
1300 /* for block groups in the same raid type */
1301 struct list_head list;
Yan Zhengd2fb3432008-12-11 16:30:39 -05001302
1303 /* usage count */
1304 atomic_t count;
Chris Masonfa9c0d792009-04-03 09:47:43 -04001305
1306 /* List of struct btrfs_free_clusters for this block group.
1307 * Today it will only have one thing on it, but that may change
1308 */
1309 struct list_head cluster_list;
Josef Bacikea658ba2012-09-11 16:57:25 -04001310
Josef Bacik47ab2a62014-09-18 11:20:02 -04001311 /* For delayed block group creation or deletion of empty block groups */
1312 struct list_head bg_list;
Josef Bacik633c0aa2014-10-31 09:49:34 -04001313
1314 /* For read-only block groups */
1315 struct list_head ro_list;
Filipe Manana04216822014-11-27 21:14:15 +00001316
1317 atomic_t trimming;
Chris Mason9078a3e2007-04-26 16:46:15 -04001318};
Chris Mason0b86a832008-03-24 15:01:56 -04001319
Jan Schmidt097b8a72012-06-21 11:08:04 +02001320/* delayed seq elem */
1321struct seq_list {
1322 struct list_head list;
1323 u64 seq;
1324};
1325
Josef Bacik5d803662013-02-07 16:06:02 -05001326enum btrfs_orphan_cleanup_state {
1327 ORPHAN_CLEANUP_STARTED = 1,
1328 ORPHAN_CLEANUP_DONE = 2,
1329};
1330
David Woodhouse53b381b2013-01-29 18:40:14 -05001331/* used by the raid56 code to lock stripes for read/modify/write */
1332struct btrfs_stripe_hash {
1333 struct list_head hash_list;
1334 wait_queue_head_t wait;
1335 spinlock_t lock;
1336};
1337
1338/* used by the raid56 code to lock stripes for read/modify/write */
1339struct btrfs_stripe_hash_table {
Chris Mason4ae10b32013-01-31 14:42:09 -05001340 struct list_head stripe_cache;
1341 spinlock_t cache_lock;
1342 int cache_size;
1343 struct btrfs_stripe_hash table[];
David Woodhouse53b381b2013-01-29 18:40:14 -05001344};
1345
1346#define BTRFS_STRIPE_HASH_TABLE_BITS 11
1347
Miao Xie21c7e752014-05-13 17:29:04 -07001348void btrfs_init_async_reclaim_work(struct work_struct *work);
1349
Jan Schmidt097b8a72012-06-21 11:08:04 +02001350/* fs_info */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001351struct reloc_control;
Chris Mason0b86a832008-03-24 15:01:56 -04001352struct btrfs_device;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001353struct btrfs_fs_devices;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001354struct btrfs_balance_control;
Miao Xie16cdcec2011-04-22 18:12:22 +08001355struct btrfs_delayed_root;
Chris Mason9f5fae22007-03-20 14:38:32 -04001356struct btrfs_fs_info {
Chris Mason5f39d392007-10-15 16:14:19 -04001357 u8 fsid[BTRFS_FSID_SIZE];
Chris Masone17cade2008-04-15 15:41:47 -04001358 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason9f5fae22007-03-20 14:38:32 -04001359 struct btrfs_root *extent_root;
1360 struct btrfs_root *tree_root;
Chris Mason0b86a832008-03-24 15:01:56 -04001361 struct btrfs_root *chunk_root;
1362 struct btrfs_root *dev_root;
Chris Mason3de45862008-11-17 21:02:50 -05001363 struct btrfs_root *fs_root;
Chris Masond20f7042008-12-08 16:58:54 -05001364 struct btrfs_root *csum_root;
Arne Jansen416ac512011-09-13 12:56:09 +02001365 struct btrfs_root *quota_root;
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02001366 struct btrfs_root *uuid_root;
Chris Masone02119d2008-09-05 16:13:11 -04001367
1368 /* the log root tree is a directory of all the other log roots */
1369 struct btrfs_root *log_root_tree;
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001370
1371 spinlock_t fs_roots_radix_lock;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001372 struct radix_tree_root fs_roots_radix;
Chris Mason1a5bc162007-10-15 16:15:26 -04001373
Josef Bacik0f9dd462008-09-23 13:14:11 -04001374 /* block group cache stuff */
1375 spinlock_t block_group_cache_lock;
Liu Boa1897fd2012-12-27 09:01:23 +00001376 u64 first_logical_byte;
Josef Bacik0f9dd462008-09-23 13:14:11 -04001377 struct rb_root block_group_cache_tree;
1378
Josef Bacik2bf64752011-09-26 17:12:22 -04001379 /* keep track of unallocated space */
1380 spinlock_t free_chunk_lock;
1381 u64 free_chunk_space;
1382
Yan Zheng11833d62009-09-11 16:11:19 -04001383 struct extent_io_tree freed_extents[2];
1384 struct extent_io_tree *pinned_extents;
Chris Mason1a5bc162007-10-15 16:15:26 -04001385
Chris Mason0b86a832008-03-24 15:01:56 -04001386 /* logical->physical extent mapping */
1387 struct btrfs_mapping_tree mapping_tree;
1388
Miao Xie16cdcec2011-04-22 18:12:22 +08001389 /*
1390 * block reservation for extent, checksum, root tree and
1391 * delayed dir index item
1392 */
Yan, Zhengf0486c62010-05-16 10:46:25 -04001393 struct btrfs_block_rsv global_block_rsv;
1394 /* block reservation for delay allocation */
1395 struct btrfs_block_rsv delalloc_block_rsv;
1396 /* block reservation for metadata operations */
1397 struct btrfs_block_rsv trans_block_rsv;
1398 /* block reservation for chunk tree */
1399 struct btrfs_block_rsv chunk_block_rsv;
Josef Bacik6d668dd2011-11-03 22:54:25 -04001400 /* block reservation for delayed operations */
1401 struct btrfs_block_rsv delayed_block_rsv;
Yan, Zhengf0486c62010-05-16 10:46:25 -04001402
1403 struct btrfs_block_rsv empty_block_rsv;
1404
Chris Mason293ffd52007-03-20 15:57:25 -04001405 u64 generation;
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001406 u64 last_trans_committed;
Josef Bacik0a2b2a82014-01-23 10:54:11 -05001407 u64 avg_delayed_ref_runtime;
Chris Mason12fcfd22009-03-24 10:24:20 -04001408
1409 /*
1410 * this is updated to the current trans every time a full commit
1411 * is required instead of the faster short fsync log commits
1412 */
1413 u64 last_trans_log_full_commit;
Stefan Behrens25cd9992012-03-30 13:58:32 +02001414 unsigned long mount_opt;
David Sterba572d9ab2014-02-05 15:26:17 +01001415 /*
1416 * Track requests for actions that need to be done during transaction
1417 * commit (like for some mount options).
1418 */
1419 unsigned long pending_changes;
Li Zefan261507a02010-12-17 14:21:50 +08001420 unsigned long compress_type:4;
David Sterba8b87dc12013-08-01 18:14:52 +02001421 int commit_interval;
Miao Xie8c6a3ee2013-01-29 10:05:05 +00001422 /*
1423 * It is a suggestive number, the read side is safe even it gets a
1424 * wrong number because we will write out the data into a regular
1425 * extent. The write side(mount/remount) is under ->s_umount lock,
1426 * so it is also safe.
1427 */
Chris Mason6f568d32008-01-29 16:03:38 -05001428 u64 max_inline;
Miao Xiec018dae2013-01-29 10:07:33 +00001429 /*
1430 * Protected by ->chunk_mutex and sb->s_umount.
1431 *
1432 * The reason that we use two lock to protect it is because only
1433 * remount and mount operations can change it and these two operations
1434 * are under sb->s_umount, but the read side (chunk allocation) can not
1435 * acquire sb->s_umount or the deadlock would happen. So we use two
1436 * locks to protect it. On the write side, we must acquire two locks,
1437 * and on the read side, we just need acquire one of them.
1438 */
Chris Mason8f662a72008-01-02 10:01:11 -05001439 u64 alloc_start;
Chris Mason79154b12007-03-22 15:59:16 -04001440 struct btrfs_transaction *running_transaction;
Chris Masone6dcd2d2008-07-17 12:53:50 -04001441 wait_queue_head_t transaction_throttle;
Chris Masonf9295742008-07-17 12:54:14 -04001442 wait_queue_head_t transaction_wait;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001443 wait_queue_head_t transaction_blocked_wait;
Chris Mason771ed682008-11-06 22:02:51 -05001444 wait_queue_head_t async_submit_wait;
Chris Masone02119d2008-09-05 16:13:11 -04001445
Miao Xieceda0862013-04-11 10:30:16 +00001446 /*
1447 * Used to protect the incompat_flags, compat_flags, compat_ro_flags
1448 * when they are updated.
1449 *
1450 * Because we do not clear the flags for ever, so we needn't use
1451 * the lock on the read side.
1452 *
1453 * We also needn't use the lock when we mount the fs, because
1454 * there is no other task which will update the flag.
1455 */
1456 spinlock_t super_lock;
David Sterba6c417612011-04-13 15:41:04 +02001457 struct btrfs_super_block *super_copy;
1458 struct btrfs_super_block *super_for_commit;
Chris Mason0b86a832008-03-24 15:01:56 -04001459 struct block_device *__bdev;
Chris Masone20d96d2007-03-22 12:13:20 -04001460 struct super_block *sb;
Chris Masond98237b2007-03-28 13:57:48 -04001461 struct inode *btree_inode;
Chris Mason04160082008-03-26 10:28:07 -04001462 struct backing_dev_info bdi;
Chris Masone02119d2008-09-05 16:13:11 -04001463 struct mutex tree_log_mutex;
Chris Masona74a4b92008-06-25 16:01:31 -04001464 struct mutex transaction_kthread_mutex;
1465 struct mutex cleaner_mutex;
Chris Mason925baed2008-06-25 16:01:30 -04001466 struct mutex chunk_mutex;
Chris Mason7d9eb122008-07-08 14:19:17 -04001467 struct mutex volume_mutex;
David Woodhouse53b381b2013-01-29 18:40:14 -05001468
1469 /* this is used during read/modify/write to make sure
1470 * no two ios are trying to mod the same stripe at the same
1471 * time
1472 */
1473 struct btrfs_stripe_hash_table *stripe_hash_table;
1474
Chris Mason5a3f23d2009-03-31 13:27:11 -04001475 /*
1476 * this protects the ordered operations list only while we are
1477 * processing all of the entries on it. This way we make
1478 * sure the commit code doesn't find the list temporarily empty
1479 * because another function happens to be doing non-waiting preflush
1480 * before jumping into the main commit.
1481 */
1482 struct mutex ordered_operations_mutex;
Josef Bacik9ffba8c2013-08-14 11:33:56 -04001483
1484 /*
1485 * Same as ordered_operations_mutex except this is for ordered extents
1486 * and not the operations.
1487 */
1488 struct mutex ordered_extent_flush_mutex;
1489
Josef Bacik9e351cc2014-03-13 15:42:13 -04001490 struct rw_semaphore commit_root_sem;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001491
Yan, Zhengc71bf092009-11-12 09:34:40 +00001492 struct rw_semaphore cleanup_work_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -04001493
Yan, Zhengc71bf092009-11-12 09:34:40 +00001494 struct rw_semaphore subvol_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -04001495 struct srcu_struct subvol_srcu;
1496
Josef Bacika4abeea2011-04-11 17:25:13 -04001497 spinlock_t trans_lock;
Chris Mason75857172011-06-13 20:00:16 -04001498 /*
1499 * the reloc mutex goes with the trans lock, it is taken
1500 * during commit to protect us from the relocation code
1501 */
1502 struct mutex reloc_mutex;
1503
Chris Mason8fd17792007-04-19 21:01:03 -04001504 struct list_head trans_list;
Chris Masonfacda1e2007-06-08 18:11:48 -04001505 struct list_head dead_roots;
Yan Zheng11833d62009-09-11 16:11:19 -04001506 struct list_head caching_block_groups;
Chris Masone02119d2008-09-05 16:13:11 -04001507
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001508 spinlock_t delayed_iput_lock;
1509 struct list_head delayed_iputs;
1510
Jan Schmidtf29021b2012-05-16 17:55:38 +02001511 /* this protects tree_mod_seq_list */
1512 spinlock_t tree_mod_seq_lock;
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +00001513 atomic64_t tree_mod_seq;
Jan Schmidtf29021b2012-05-16 17:55:38 +02001514 struct list_head tree_mod_seq_list;
1515
1516 /* this protects tree_mod_log */
1517 rwlock_t tree_mod_log_lock;
1518 struct rb_root tree_mod_log;
1519
Chris Masoncb03c742008-05-15 16:15:45 -04001520 atomic_t nr_async_submits;
Chris Mason8c8bee12008-09-29 11:19:10 -04001521 atomic_t async_submit_draining;
Chris Mason0986fe9e2008-08-15 15:34:15 -04001522 atomic_t nr_async_bios;
Chris Mason771ed682008-11-06 22:02:51 -05001523 atomic_t async_delalloc_pages;
Josef Bacika4abeea2011-04-11 17:25:13 -04001524 atomic_t open_ioctl_trans;
Chris Masonce9adaa2008-04-09 16:28:12 -04001525
Chris Mason8b712842008-06-11 16:50:36 -04001526 /*
Miao Xie199c2a92013-05-15 07:48:23 +00001527 * this is used to protect the following list -- ordered_roots.
Chris Mason3eaa2882008-07-24 11:57:52 -04001528 */
Miao Xie199c2a92013-05-15 07:48:23 +00001529 spinlock_t ordered_root_lock;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001530
1531 /*
Miao Xie199c2a92013-05-15 07:48:23 +00001532 * all fs/file tree roots in which there are data=ordered extents
1533 * pending writeback are added into this list.
1534 *
Chris Mason5a3f23d2009-03-31 13:27:11 -04001535 * these can span multiple transactions and basically include
1536 * every dirty data page that isn't from nodatacow
1537 */
Miao Xie199c2a92013-05-15 07:48:23 +00001538 struct list_head ordered_roots;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001539
Miao Xie573bfb72014-03-06 13:55:03 +08001540 struct mutex delalloc_root_mutex;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001541 spinlock_t delalloc_root_lock;
1542 /* all fs/file tree roots that have delalloc inodes. */
1543 struct list_head delalloc_roots;
Chris Mason3eaa2882008-07-24 11:57:52 -04001544
1545 /*
Chris Mason8b712842008-06-11 16:50:36 -04001546 * there is a pool of worker threads for checksumming during writes
1547 * and a pool for checksumming after reads. This is because readers
1548 * can run with FS locks held, and the writers may be waiting for
1549 * those locks. We don't want ordering in the pending list to cause
1550 * deadlocks, and so the two are serviced separately.
Chris Mason1cc127b2008-06-12 14:46:17 -04001551 *
1552 * A third pool does submit_bio to avoid deadlocking with the other
1553 * two
Chris Mason8b712842008-06-11 16:50:36 -04001554 */
Qu Wenruod458b052014-02-28 10:46:19 +08001555 struct btrfs_workqueue *workers;
1556 struct btrfs_workqueue *delalloc_workers;
1557 struct btrfs_workqueue *flush_workers;
1558 struct btrfs_workqueue *endio_workers;
1559 struct btrfs_workqueue *endio_meta_workers;
1560 struct btrfs_workqueue *endio_raid56_workers;
Miao Xie8b110e32014-09-12 18:44:03 +08001561 struct btrfs_workqueue *endio_repair_workers;
Qu Wenruod458b052014-02-28 10:46:19 +08001562 struct btrfs_workqueue *rmw_workers;
1563 struct btrfs_workqueue *endio_meta_write_workers;
1564 struct btrfs_workqueue *endio_write_workers;
1565 struct btrfs_workqueue *endio_freespace_worker;
1566 struct btrfs_workqueue *submit_workers;
1567 struct btrfs_workqueue *caching_workers;
1568 struct btrfs_workqueue *readahead_workers;
Josef Bacikbab39bf2011-06-30 14:42:28 -04001569
Chris Mason247e7432008-07-17 12:53:51 -04001570 /*
1571 * fixup workers take dirty pages that didn't properly go through
1572 * the cow mechanism and make them safe to write. It happens
1573 * for the sys_munmap function call path
1574 */
Qu Wenruod458b052014-02-28 10:46:19 +08001575 struct btrfs_workqueue *fixup_workers;
1576 struct btrfs_workqueue *delayed_workers;
Chris Masona79b7d42014-05-22 16:18:52 -07001577
1578 /* the extent workers do delayed refs on the extent allocation tree */
1579 struct btrfs_workqueue *extent_workers;
Chris Masona74a4b92008-06-25 16:01:31 -04001580 struct task_struct *transaction_kthread;
1581 struct task_struct *cleaner_kthread;
Chris Mason4543df72008-06-11 21:47:56 -04001582 int thread_pool_size;
Chris Mason8b712842008-06-11 16:50:36 -04001583
Josef Bacik58176a92007-08-29 15:47:34 -04001584 struct kobject super_kobj;
Jeff Mahoney6ab0a202013-11-01 13:07:04 -04001585 struct kobject *space_info_kobj;
Jeff Mahoney29e5be22013-11-01 13:07:05 -04001586 struct kobject *device_dir_kobj;
Josef Bacik58176a92007-08-29 15:47:34 -04001587 struct completion kobj_unregister;
Chris Masone66f7092007-04-20 13:16:02 -04001588 int do_barriers;
Chris Masonfacda1e2007-06-08 18:11:48 -04001589 int closing;
Chris Masone02119d2008-09-05 16:13:11 -04001590 int log_root_recovering;
Josef Bacik47ab2a62014-09-18 11:20:02 -04001591 int open;
Chris Mason62e27492007-03-15 12:56:47 -04001592
Yan324ae4d2007-11-16 14:57:08 -05001593 u64 total_pinned;
Chris Masonb9473432009-03-13 11:00:37 -04001594
Miao Xiee2d84522013-01-29 10:09:20 +00001595 /* used to keep from writing metadata until there is a nice batch */
1596 struct percpu_counter dirty_metadata_bytes;
Miao Xie963d6782013-01-29 10:10:51 +00001597 struct percpu_counter delalloc_bytes;
Miao Xiee2d84522013-01-29 10:09:20 +00001598 s32 dirty_metadata_batch;
Miao Xie963d6782013-01-29 10:10:51 +00001599 s32 delalloc_batch;
1600
Chris Mason0b86a832008-03-24 15:01:56 -04001601 struct list_head dirty_cowonly_roots;
1602
Chris Mason8a4b83c2008-03-24 15:02:07 -04001603 struct btrfs_fs_devices *fs_devices;
Chris Mason4184ea72009-03-10 12:39:20 -04001604
1605 /*
1606 * the space_info list is almost entirely read only. It only changes
1607 * when we add a new raid type to the FS, and that happens
1608 * very rarely. RCU is used to protect it.
1609 */
Chris Mason6324fbf2008-03-24 15:01:59 -04001610 struct list_head space_info;
Chris Mason4184ea72009-03-10 12:39:20 -04001611
Li Zefanb4d7c3c2012-07-09 20:21:07 -06001612 struct btrfs_space_info *data_sinfo;
1613
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001614 struct reloc_control *reloc_ctl;
1615
Chris Masonfa9c0d792009-04-03 09:47:43 -04001616 /* data_alloc_cluster is only used in ssd mode */
1617 struct btrfs_free_cluster data_alloc_cluster;
1618
1619 /* all metadata allocations go through this cluster */
1620 struct btrfs_free_cluster meta_alloc_cluster;
Chris Masond18a2c42008-04-04 15:40:00 -04001621
Chris Mason4cb53002011-05-24 15:35:30 -04001622 /* auto defrag inodes go here */
1623 spinlock_t defrag_inodes_lock;
1624 struct rb_root defrag_inodes;
1625 atomic_t defrag_running;
1626
Miao Xiede98ced2013-01-29 10:13:12 +00001627 /* Used to protect avail_{data, metadata, system}_alloc_bits */
1628 seqlock_t profiles_lock;
Ilya Dryomova46d11a2012-01-16 22:04:47 +02001629 /*
1630 * these three are in extended format (availability of single
1631 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
1632 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
1633 */
Chris Masond18a2c42008-04-04 15:40:00 -04001634 u64 avail_data_alloc_bits;
1635 u64 avail_metadata_alloc_bits;
1636 u64 avail_system_alloc_bits;
Chris Mason788f20e2008-04-28 15:29:42 -04001637
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001638 /* restriper state */
1639 spinlock_t balance_lock;
1640 struct mutex balance_mutex;
Ilya Dryomov837d5b62012-01-16 22:04:49 +02001641 atomic_t balance_running;
1642 atomic_t balance_pause_req;
Ilya Dryomova7e99c62012-01-16 22:04:49 +02001643 atomic_t balance_cancel_req;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001644 struct btrfs_balance_control *balance_ctl;
Ilya Dryomov837d5b62012-01-16 22:04:49 +02001645 wait_queue_head_t balance_wait_q;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001646
Josef Bacik97e728d2009-04-21 17:40:57 -04001647 unsigned data_chunk_allocations;
1648 unsigned metadata_ratio;
1649
Chris Mason788f20e2008-04-28 15:29:42 -04001650 void *bdev_holder;
liuboacce9522011-01-06 19:30:25 +08001651
Arne Jansena2de7332011-03-08 14:14:00 +01001652 /* private scrub information */
1653 struct mutex scrub_lock;
1654 atomic_t scrubs_running;
1655 atomic_t scrub_pause_req;
1656 atomic_t scrubs_paused;
1657 atomic_t scrub_cancel_req;
1658 wait_queue_head_t scrub_pause_wait;
Arne Jansena2de7332011-03-08 14:14:00 +01001659 int scrub_workers_refcnt;
Qu Wenruod458b052014-02-28 10:46:19 +08001660 struct btrfs_workqueue *scrub_workers;
1661 struct btrfs_workqueue *scrub_wr_completion_workers;
1662 struct btrfs_workqueue *scrub_nocow_workers;
Arne Jansena2de7332011-03-08 14:14:00 +01001663
Stefan Behrens21adbd52011-11-09 13:44:05 +01001664#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1665 u32 check_integrity_print_mask;
1666#endif
Arne Jansen416ac512011-09-13 12:56:09 +02001667 /*
1668 * quota information
1669 */
1670 unsigned int quota_enabled:1;
1671
1672 /*
1673 * quota_enabled only changes state after a commit. This holds the
1674 * next state.
1675 */
1676 unsigned int pending_quota_state:1;
1677
1678 /* is qgroup tracking in a consistent state? */
1679 u64 qgroup_flags;
1680
1681 /* holds configuration and tracking. Protected by qgroup_lock */
1682 struct rb_root qgroup_tree;
Josef Bacikfcebe452014-05-13 17:30:47 -07001683 struct rb_root qgroup_op_tree;
Arne Jansen416ac512011-09-13 12:56:09 +02001684 spinlock_t qgroup_lock;
Josef Bacikfcebe452014-05-13 17:30:47 -07001685 spinlock_t qgroup_op_lock;
1686 atomic_t qgroup_op_seq;
Arne Jansen416ac512011-09-13 12:56:09 +02001687
Wang Shilong1e8f9152013-05-06 11:03:27 +00001688 /*
1689 * used to avoid frequently calling ulist_alloc()/ulist_free()
1690 * when doing qgroup accounting, it must be protected by qgroup_lock.
1691 */
1692 struct ulist *qgroup_ulist;
1693
Wang Shilongf2f6ed32013-04-07 10:50:16 +00001694 /* protect user change for quota operations */
1695 struct mutex qgroup_ioctl_lock;
1696
Arne Jansen416ac512011-09-13 12:56:09 +02001697 /* list of dirty qgroups to be written at next commit */
1698 struct list_head dirty_qgroups;
1699
1700 /* used by btrfs_qgroup_record_ref for an efficient tree traversal */
1701 u64 qgroup_seq;
Stefan Behrens21adbd52011-11-09 13:44:05 +01001702
Jan Schmidt2f232032013-04-25 16:04:51 +00001703 /* qgroup rescan items */
1704 struct mutex qgroup_rescan_lock; /* protects the progress item */
1705 struct btrfs_key qgroup_rescan_progress;
Qu Wenruod458b052014-02-28 10:46:19 +08001706 struct btrfs_workqueue *qgroup_rescan_workers;
Jan Schmidt57254b6e2013-05-06 19:14:17 +00001707 struct completion qgroup_rescan_completion;
Jan Schmidtb382a322013-05-28 15:47:24 +00001708 struct btrfs_work qgroup_rescan_work;
Jan Schmidt2f232032013-04-25 16:04:51 +00001709
liuboacce9522011-01-06 19:30:25 +08001710 /* filesystem state */
Miao Xie87533c42013-01-29 10:14:48 +00001711 unsigned long fs_state;
Miao Xie16cdcec2011-04-22 18:12:22 +08001712
1713 struct btrfs_delayed_root *delayed_root;
Chris Masonaf31f5e2011-11-03 15:17:42 -04001714
Arne Jansen90519d62011-05-23 14:30:00 +02001715 /* readahead tree */
1716 spinlock_t reada_lock;
1717 struct radix_tree_root reada_tree;
Chris Mason531f4b1a2011-11-06 03:05:08 -05001718
Josef Bacikf28491e2013-12-16 13:24:27 -05001719 /* Extent buffer radix tree */
1720 spinlock_t buffer_lock;
1721 struct radix_tree_root buffer_radix;
1722
Chris Masonaf31f5e2011-11-03 15:17:42 -04001723 /* next backup root to be overwritten */
1724 int backup_root_index;
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02001725
1726 int num_tolerated_disk_barrier_failures;
Stefan Behrense922e082012-11-05 17:26:40 +01001727
1728 /* device replace state */
1729 struct btrfs_dev_replace dev_replace;
Stefan Behrens5ac00ad2012-11-05 17:54:08 +01001730
1731 atomic_t mutually_exclusive_operation_running;
Stefan Behrens803b2f52013-08-15 17:11:21 +02001732
Miao Xiec404e0d2014-01-30 16:46:55 +08001733 struct percpu_counter bio_counter;
1734 wait_queue_head_t replace_wait;
1735
Stefan Behrens803b2f52013-08-15 17:11:21 +02001736 struct semaphore uuid_tree_rescan_sem;
Stefan Behrens70f80172013-08-15 17:11:23 +02001737 unsigned int update_uuid_tree_gen:1;
Miao Xie21c7e752014-05-13 17:29:04 -07001738
1739 /* Used to reclaim the metadata space in the background. */
1740 struct work_struct async_reclaim_work;
Josef Bacik47ab2a62014-09-18 11:20:02 -04001741
1742 spinlock_t unused_bgs_lock;
1743 struct list_head unused_bgs;
Qu Wenruof667aef2014-09-23 13:40:08 +08001744
1745 /* For btrfs to record security options */
1746 struct security_mnt_opts security_opts;
Filipe Manana04216822014-11-27 21:14:15 +00001747
1748 /*
1749 * Chunks that can't be freed yet (under a trim/discard operation)
1750 * and will be latter freed. Protected by fs_info->chunk_mutex.
1751 */
1752 struct list_head pinned_chunks;
Yan324ae4d2007-11-16 14:57:08 -05001753};
Chris Mason0b86a832008-03-24 15:01:56 -04001754
Miao Xie8257b2d2014-03-06 13:38:19 +08001755struct btrfs_subvolume_writers {
1756 struct percpu_counter counter;
1757 wait_queue_head_t wait;
1758};
1759
Chris Mason62e27492007-03-15 12:56:47 -04001760/*
Miao Xie27cdeb72014-04-02 19:51:05 +08001761 * The state of btrfs root
1762 */
1763/*
1764 * btrfs_record_root_in_trans is a multi-step process,
1765 * and it can race with the balancing code. But the
1766 * race is very small, and only the first time the root
1767 * is added to each transaction. So IN_TRANS_SETUP
1768 * is used to tell us when more checks are required
1769 */
1770#define BTRFS_ROOT_IN_TRANS_SETUP 0
1771#define BTRFS_ROOT_REF_COWS 1
1772#define BTRFS_ROOT_TRACK_DIRTY 2
1773#define BTRFS_ROOT_IN_RADIX 3
1774#define BTRFS_ROOT_DUMMY_ROOT 4
1775#define BTRFS_ROOT_ORPHAN_ITEM_INSERTED 5
1776#define BTRFS_ROOT_DEFRAG_RUNNING 6
1777#define BTRFS_ROOT_FORCE_COW 7
1778#define BTRFS_ROOT_MULTI_LOG_TASKS 8
1779
1780/*
Chris Mason62e27492007-03-15 12:56:47 -04001781 * in ram representation of the tree. extent_root is used for all allocations
Chris Masonf2458e12007-04-25 15:52:25 -04001782 * and for the extent tree extent_root root.
Chris Mason62e27492007-03-15 12:56:47 -04001783 */
1784struct btrfs_root {
Chris Mason5f39d392007-10-15 16:14:19 -04001785 struct extent_buffer *node;
Chris Mason925baed2008-06-25 16:01:30 -04001786
Chris Mason5f39d392007-10-15 16:14:19 -04001787 struct extent_buffer *commit_root;
Chris Masone02119d2008-09-05 16:13:11 -04001788 struct btrfs_root *log_root;
Zheng Yan1a40e232008-09-26 10:09:34 -04001789 struct btrfs_root *reloc_root;
Yan Zheng31153d82008-07-28 15:32:19 -04001790
Miao Xie27cdeb72014-04-02 19:51:05 +08001791 unsigned long state;
Chris Mason62e27492007-03-15 12:56:47 -04001792 struct btrfs_root_item root_item;
1793 struct btrfs_key root_key;
Chris Mason9f5fae22007-03-20 14:38:32 -04001794 struct btrfs_fs_info *fs_info;
Chris Masond0c803c2008-09-11 16:17:57 -04001795 struct extent_io_tree dirty_log_pages;
1796
Josef Bacik58176a92007-08-29 15:47:34 -04001797 struct kobject root_kobj;
1798 struct completion kobj_unregister;
Chris Masona2135012008-06-25 16:01:30 -04001799 struct mutex objectid_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001800
Yan, Zhengf0486c62010-05-16 10:46:25 -04001801 spinlock_t accounting_lock;
1802 struct btrfs_block_rsv *block_rsv;
1803
Li Zefan581bb052011-04-20 10:06:11 +08001804 /* free ino cache stuff */
Li Zefan581bb052011-04-20 10:06:11 +08001805 struct btrfs_free_space_ctl *free_ino_ctl;
David Sterba57cdc8d2014-02-05 02:37:48 +01001806 enum btrfs_caching_type ino_cache_state;
1807 spinlock_t ino_cache_lock;
1808 wait_queue_head_t ino_cache_wait;
Li Zefan581bb052011-04-20 10:06:11 +08001809 struct btrfs_free_space_ctl *free_ino_pinned;
David Sterba57cdc8d2014-02-05 02:37:48 +01001810 u64 ino_cache_progress;
1811 struct inode *ino_cache_inode;
Li Zefan581bb052011-04-20 10:06:11 +08001812
Chris Masone02119d2008-09-05 16:13:11 -04001813 struct mutex log_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001814 wait_queue_head_t log_writer_wait;
1815 wait_queue_head_t log_commit_wait[2];
Miao Xie8b050d32014-02-20 18:08:58 +08001816 struct list_head log_ctxs[2];
Yan Zheng7237f182009-01-21 12:54:03 -05001817 atomic_t log_writers;
1818 atomic_t log_commit[2];
Miao Xie2ecb7922012-09-06 04:04:27 -06001819 atomic_t log_batch;
Miao Xiebb14a592014-02-20 18:08:56 +08001820 int log_transid;
Miao Xied1433de2014-02-20 18:08:59 +08001821 /* No matter the commit succeeds or not*/
1822 int log_transid_committed;
1823 /* Just be updated when the commit succeeds. */
Miao Xiebb14a592014-02-20 18:08:56 +08001824 int last_log_commit;
Josef Bacikff782e02009-10-08 15:30:04 -04001825 pid_t log_start_pid;
Chris Masonea8c2812008-08-04 23:17:27 -04001826
Chris Mason0f7d52f2007-04-09 10:42:37 -04001827 u64 objectid;
1828 u64 last_trans;
Chris Mason5f39d392007-10-15 16:14:19 -04001829
1830 /* data allocations are done in sectorsize units */
1831 u32 sectorsize;
1832
1833 /* node allocations are done in nodesize units */
1834 u32 nodesize;
1835
Chris Mason87ee04e2007-11-30 11:30:34 -05001836 u32 stripesize;
1837
Chris Mason9f5fae22007-03-20 14:38:32 -04001838 u32 type;
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001839
1840 u64 highest_objectid;
Chris Mason75857172011-06-13 20:00:16 -04001841
Chris Mason0d4cf4e2014-10-07 13:24:20 -07001842 /* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */
Josef Bacikfaa2dbf2014-05-07 17:06:09 -04001843 u64 alloc_bytenr;
Josef Bacikfaa2dbf2014-05-07 17:06:09 -04001844
Chris Mason3f157a22008-06-25 16:01:31 -04001845 u64 defrag_trans_start;
Chris Mason6702ed42007-08-07 16:15:09 -04001846 struct btrfs_key defrag_progress;
Chris Mason0ef3e662008-05-24 14:04:53 -04001847 struct btrfs_key defrag_max;
Josef Bacik58176a92007-08-29 15:47:34 -04001848 char *name;
Chris Mason0b86a832008-03-24 15:01:56 -04001849
1850 /* the dirty list is only used by non-reference counted roots */
1851 struct list_head dirty_list;
Josef Bacik7b128762008-07-24 12:17:14 -04001852
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001853 struct list_head root_list;
1854
Josef Bacik2ab28f32012-10-12 15:27:49 -04001855 spinlock_t log_extents_lock[2];
1856 struct list_head logged_list[2];
1857
Yan, Zhengd68fc572010-05-16 10:49:58 -04001858 spinlock_t orphan_lock;
Josef Bacik8a35d952012-05-23 14:26:42 -04001859 atomic_t orphan_inodes;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001860 struct btrfs_block_rsv *orphan_block_rsv;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001861 int orphan_cleanup_state;
Chris Mason3394e162008-11-17 20:42:26 -05001862
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001863 spinlock_t inode_lock;
1864 /* red-black tree that keeps track of in-memory inodes */
1865 struct rb_root inode_tree;
1866
Chris Mason3394e162008-11-17 20:42:26 -05001867 /*
Miao Xie16cdcec2011-04-22 18:12:22 +08001868 * radix tree that keeps track of delayed nodes of every inode,
1869 * protected by inode_lock
1870 */
1871 struct radix_tree_root delayed_nodes_tree;
1872 /*
Chris Mason3394e162008-11-17 20:42:26 -05001873 * right now this just gets used so that a root has its own devid
1874 * for stat. It may be used for more later
1875 */
Al Viro0ee5dc62011-07-07 15:44:25 -04001876 dev_t anon_dev;
Liu Bof1ebcc72011-11-14 20:48:06 -05001877
Anand Jain5f3ab902012-12-07 09:28:54 +00001878 spinlock_t root_item_lock;
Miao Xieb0feb9d2013-05-15 07:48:20 +00001879 atomic_t refs;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001880
Miao Xie573bfb72014-03-06 13:55:03 +08001881 struct mutex delalloc_mutex;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001882 spinlock_t delalloc_lock;
1883 /*
1884 * all of the inodes that have delalloc bytes. It is possible for
1885 * this list to be empty even when there is still dirty data=ordered
1886 * extents waiting to finish IO.
1887 */
1888 struct list_head delalloc_inodes;
1889 struct list_head delalloc_root;
1890 u64 nr_delalloc_inodes;
Miao Xie31f3d252014-03-06 13:55:02 +08001891
1892 struct mutex ordered_extent_mutex;
Miao Xie199c2a92013-05-15 07:48:23 +00001893 /*
1894 * this is used by the balancing code to wait for all the pending
1895 * ordered extents
1896 */
1897 spinlock_t ordered_extent_lock;
1898
1899 /*
1900 * all of the data=ordered extents pending writeback
1901 * these can span multiple transactions and basically include
1902 * every dirty data page that isn't from nodatacow
1903 */
1904 struct list_head ordered_extents;
1905 struct list_head ordered_root;
1906 u64 nr_ordered_extents;
David Sterba2c686532013-12-16 17:34:17 +01001907
1908 /*
1909 * Number of currently running SEND ioctls to prevent
1910 * manipulation with the read-only status via SUBVOL_SETFLAGS
1911 */
1912 int send_in_progress;
Miao Xie8257b2d2014-03-06 13:38:19 +08001913 struct btrfs_subvolume_writers *subv_writers;
1914 atomic_t will_be_snapshoted;
Chris Mason62e27492007-03-15 12:56:47 -04001915};
1916
Chris Mason4cb53002011-05-24 15:35:30 -04001917struct btrfs_ioctl_defrag_range_args {
1918 /* start of the defrag operation */
1919 __u64 start;
1920
1921 /* number of bytes to defrag, use (u64)-1 to say all */
1922 __u64 len;
1923
1924 /*
1925 * flags for the operation, which can include turning
1926 * on compression for this one defrag
1927 */
1928 __u64 flags;
1929
1930 /*
1931 * any extent bigger than this will be considered
1932 * already defragged. Use 0 to take the kernel default
1933 * Use 1 to say every single extent must be rewritten
1934 */
1935 __u32 extent_thresh;
1936
1937 /*
1938 * which compression method to use if turning on compression
1939 * for this defrag operation. If unspecified, zlib will
1940 * be used
1941 */
1942 __u32 compress_type;
1943
1944 /* spare for later */
1945 __u32 unused[4];
1946};
1947
1948
Chris Mason1e1d2702007-03-15 19:03:33 -04001949/*
1950 * inode items have the data typically returned from stat and store other
1951 * info about object characteristics. There is one for every file and dir in
1952 * the FS
1953 */
Chris Mason9078a3e2007-04-26 16:46:15 -04001954#define BTRFS_INODE_ITEM_KEY 1
Chris Mason0660b5a2008-11-17 20:37:39 -05001955#define BTRFS_INODE_REF_KEY 12
Mark Fashehf1863732012-08-08 11:32:27 -07001956#define BTRFS_INODE_EXTREF_KEY 13
Chris Mason0660b5a2008-11-17 20:37:39 -05001957#define BTRFS_XATTR_ITEM_KEY 24
1958#define BTRFS_ORPHAN_ITEM_KEY 48
Chris Mason9078a3e2007-04-26 16:46:15 -04001959/* reserve 2-15 close to the inode for later flexibility */
Chris Mason1e1d2702007-03-15 19:03:33 -04001960
1961/*
1962 * dir items are the name -> inode pointers in a directory. There is one
1963 * for every name in a directory.
1964 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001965#define BTRFS_DIR_LOG_ITEM_KEY 60
1966#define BTRFS_DIR_LOG_INDEX_KEY 72
1967#define BTRFS_DIR_ITEM_KEY 84
1968#define BTRFS_DIR_INDEX_KEY 96
Chris Mason1e1d2702007-03-15 19:03:33 -04001969/*
Chris Mason9078a3e2007-04-26 16:46:15 -04001970 * extent data is for file data
Chris Mason1e1d2702007-03-15 19:03:33 -04001971 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001972#define BTRFS_EXTENT_DATA_KEY 108
Chris Masond20f7042008-12-08 16:58:54 -05001973
Chris Mason1e1d2702007-03-15 19:03:33 -04001974/*
Chris Masond20f7042008-12-08 16:58:54 -05001975 * extent csums are stored in a separate tree and hold csums for
1976 * an entire extent on disk.
Chris Masonf254e522007-03-29 15:15:27 -04001977 */
Chris Masond20f7042008-12-08 16:58:54 -05001978#define BTRFS_EXTENT_CSUM_KEY 128
Chris Masonf254e522007-03-29 15:15:27 -04001979
1980/*
Wu Fengguangd4a78942009-04-02 16:46:06 -04001981 * root items point to tree roots. They are typically in the root
Chris Mason1e1d2702007-03-15 19:03:33 -04001982 * tree used by the super block to find all the other trees
1983 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001984#define BTRFS_ROOT_ITEM_KEY 132
1985
1986/*
1987 * root backrefs tie subvols and snapshots to the directory entries that
1988 * reference them
1989 */
1990#define BTRFS_ROOT_BACKREF_KEY 144
1991
1992/*
1993 * root refs make a fast index for listing all of the snapshots and
1994 * subvolumes referenced by a given root. They point directly to the
1995 * directory item in the root that references the subvol
1996 */
1997#define BTRFS_ROOT_REF_KEY 156
1998
Chris Mason1e1d2702007-03-15 19:03:33 -04001999/*
2000 * extent items are in the extent map tree. These record which blocks
2001 * are used, and how many references there are to each block
2002 */
Chris Mason0660b5a2008-11-17 20:37:39 -05002003#define BTRFS_EXTENT_ITEM_KEY 168
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002004
Josef Bacik3173a182013-03-07 14:22:04 -05002005/*
2006 * The same as the BTRFS_EXTENT_ITEM_KEY, except it's metadata we already know
2007 * the length, so we save the level in key->offset instead of the length.
2008 */
2009#define BTRFS_METADATA_ITEM_KEY 169
2010
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002011#define BTRFS_TREE_BLOCK_REF_KEY 176
2012
2013#define BTRFS_EXTENT_DATA_REF_KEY 178
2014
2015#define BTRFS_EXTENT_REF_V0_KEY 180
2016
2017#define BTRFS_SHARED_BLOCK_REF_KEY 182
2018
2019#define BTRFS_SHARED_DATA_REF_KEY 184
Chris Mason9078a3e2007-04-26 16:46:15 -04002020
2021/*
2022 * block groups give us hints into the extent allocation trees. Which
2023 * blocks are free etc etc
2024 */
Chris Mason0660b5a2008-11-17 20:37:39 -05002025#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
Chris Mason9f5fae22007-03-20 14:38:32 -04002026
Chris Mason0660b5a2008-11-17 20:37:39 -05002027#define BTRFS_DEV_EXTENT_KEY 204
2028#define BTRFS_DEV_ITEM_KEY 216
2029#define BTRFS_CHUNK_ITEM_KEY 228
Chris Mason0b86a832008-03-24 15:01:56 -04002030
Arne Jansen630dc772011-09-13 11:06:07 +02002031/*
2032 * Records the overall state of the qgroups.
2033 * There's only one instance of this key present,
2034 * (0, BTRFS_QGROUP_STATUS_KEY, 0)
2035 */
2036#define BTRFS_QGROUP_STATUS_KEY 240
2037/*
2038 * Records the currently used space of the qgroup.
2039 * One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid).
2040 */
2041#define BTRFS_QGROUP_INFO_KEY 242
2042/*
2043 * Contains the user configured limits for the qgroup.
2044 * One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid).
2045 */
2046#define BTRFS_QGROUP_LIMIT_KEY 244
2047/*
2048 * Records the child-parent relationship of qgroups. For
2049 * each relation, 2 keys are present:
2050 * (childid, BTRFS_QGROUP_RELATION_KEY, parentid)
2051 * (parentid, BTRFS_QGROUP_RELATION_KEY, childid)
2052 */
2053#define BTRFS_QGROUP_RELATION_KEY 246
2054
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002055#define BTRFS_BALANCE_ITEM_KEY 248
2056
Chris Mason9f5fae22007-03-20 14:38:32 -04002057/*
Stefan Behrens733f4fb2012-05-25 16:06:10 +02002058 * Persistantly stores the io stats in the device tree.
2059 * One key for all stats, (0, BTRFS_DEV_STATS_KEY, devid).
2060 */
2061#define BTRFS_DEV_STATS_KEY 249
2062
2063/*
Stefan Behrensa2bff642012-11-05 17:32:20 +01002064 * Persistantly stores the device replace state in the device tree.
2065 * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).
2066 */
2067#define BTRFS_DEV_REPLACE_KEY 250
2068
2069/*
Stefan Behrens07b30a42013-08-15 17:11:17 +02002070 * Stores items that allow to quickly map UUIDs to something else.
2071 * These items are part of the filesystem UUID tree.
2072 * The key is built like this:
2073 * (UUID_upper_64_bits, BTRFS_UUID_KEY*, UUID_lower_64_bits).
2074 */
2075#if BTRFS_UUID_SIZE != 16
2076#error "UUID items require BTRFS_UUID_SIZE == 16!"
2077#endif
2078#define BTRFS_UUID_KEY_SUBVOL 251 /* for UUIDs assigned to subvols */
2079#define BTRFS_UUID_KEY_RECEIVED_SUBVOL 252 /* for UUIDs assigned to
2080 * received subvols */
2081
2082/*
Chris Mason1e1d2702007-03-15 19:03:33 -04002083 * string items are for debugging. They just store a short string of
2084 * data in the FS
2085 */
Chris Mason9078a3e2007-04-26 16:46:15 -04002086#define BTRFS_STRING_ITEM_KEY 253
2087
David Sterba0942caa2011-06-28 15:10:37 +00002088/*
2089 * Flags for mount options.
2090 *
2091 * Note: don't forget to add new options to btrfs_show_options()
2092 */
Chris Mason21ad10c2008-01-09 09:23:21 -05002093#define BTRFS_MOUNT_NODATASUM (1 << 0)
2094#define BTRFS_MOUNT_NODATACOW (1 << 1)
2095#define BTRFS_MOUNT_NOBARRIER (1 << 2)
Chris Masone18e4802008-01-18 10:54:22 -05002096#define BTRFS_MOUNT_SSD (1 << 3)
Chris Masondfe25022008-05-13 13:46:40 -04002097#define BTRFS_MOUNT_DEGRADED (1 << 4)
Chris Masonc8b97812008-10-29 14:49:59 -04002098#define BTRFS_MOUNT_COMPRESS (1 << 5)
Sage Weil3a5e1402009-04-02 16:49:40 -04002099#define BTRFS_MOUNT_NOTREELOG (1 << 6)
Sage Weildccae992009-04-02 16:59:01 -04002100#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
Chris Mason451d7582009-06-09 20:28:34 -04002101#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
Chris Masonc2898112009-06-10 09:51:32 -04002102#define BTRFS_MOUNT_NOSSD (1 << 9)
Christoph Hellwige244a0a2009-10-14 09:24:59 -04002103#define BTRFS_MOUNT_DISCARD (1 << 10)
Chris Masona555f812010-01-28 16:18:15 -05002104#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
Josef Bacik0af3d002010-06-21 14:48:16 -04002105#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
Josef Bacik88c2ba32010-09-21 14:21:34 -04002106#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
Sage Weil4260f7c2010-10-29 15:46:43 -04002107#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
Chris Mason91435652011-02-16 13:10:41 -05002108#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
Chris Mason4cb53002011-05-24 15:35:30 -04002109#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
Chris Mason4b9465c2011-06-03 09:36:29 -04002110#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
Chris Masonaf31f5e2011-11-03 15:17:42 -04002111#define BTRFS_MOUNT_RECOVERY (1 << 18)
Ilya Dryomov9555c6c2012-01-16 22:04:48 +02002112#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
Chris Masonc126dea2012-01-16 15:27:58 -05002113#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
2114#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
Jeff Mahoney8c342932011-10-03 23:22:31 -04002115#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22)
Stefan Behrensf420ee12013-08-15 17:11:24 +02002116#define BTRFS_MOUNT_RESCAN_UUID_TREE (1 << 23)
Chris Masonb6cda9b2007-12-14 15:30:32 -05002117
David Sterba8b87dc12013-08-01 18:14:52 +02002118#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
Filipe David Borba Manana95ac5672013-08-08 22:45:48 +01002119#define BTRFS_DEFAULT_MAX_INLINE (8192)
David Sterba8b87dc12013-08-01 18:14:52 +02002120
Chris Masonb6cda9b2007-12-14 15:30:32 -05002121#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
2122#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
Miao Xiedc81cdc2013-02-20 23:32:52 -07002123#define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt)
Chris Masonb6cda9b2007-12-14 15:30:32 -05002124#define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \
2125 BTRFS_MOUNT_##opt)
David Sterba572d9ab2014-02-05 15:26:17 +01002126
Wang Shilong9d89ce62014-04-23 19:33:33 +08002127#define btrfs_set_and_info(root, opt, fmt, args...) \
2128{ \
2129 if (!btrfs_test_opt(root, opt)) \
2130 btrfs_info(root->fs_info, fmt, ##args); \
2131 btrfs_set_opt(root->fs_info->mount_opt, opt); \
2132}
2133
2134#define btrfs_clear_and_info(root, opt, fmt, args...) \
2135{ \
2136 if (btrfs_test_opt(root, opt)) \
2137 btrfs_info(root->fs_info, fmt, ##args); \
2138 btrfs_clear_opt(root->fs_info->mount_opt, opt); \
2139}
2140
Yanb98b6762008-01-08 15:54:37 -05002141/*
David Sterba572d9ab2014-02-05 15:26:17 +01002142 * Requests for changes that need to be done during transaction commit.
2143 *
2144 * Internal mount options that are used for special handling of the real
2145 * mount options (eg. cannot be set during remount and have to be set during
2146 * transaction commit)
2147 */
2148
David Sterba7e1876a2014-02-05 15:26:17 +01002149#define BTRFS_PENDING_SET_INODE_MAP_CACHE (0)
2150#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE (1)
David Sterbad51033d2014-11-12 14:24:35 +01002151#define BTRFS_PENDING_COMMIT (2)
David Sterba7e1876a2014-02-05 15:26:17 +01002152
David Sterba572d9ab2014-02-05 15:26:17 +01002153#define btrfs_test_pending(info, opt) \
2154 test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
2155#define btrfs_set_pending(info, opt) \
2156 set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
2157#define btrfs_clear_pending(info, opt) \
2158 clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
2159
2160/*
2161 * Helpers for setting pending mount option changes.
2162 *
2163 * Expects corresponding macros
2164 * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name
2165 */
2166#define btrfs_set_pending_and_info(info, opt, fmt, args...) \
2167do { \
2168 if (!btrfs_raw_test_opt((info)->mount_opt, opt)) { \
2169 btrfs_info((info), fmt, ##args); \
2170 btrfs_set_pending((info), SET_##opt); \
2171 btrfs_clear_pending((info), CLEAR_##opt); \
2172 } \
2173} while(0)
2174
2175#define btrfs_clear_pending_and_info(info, opt, fmt, args...) \
2176do { \
2177 if (btrfs_raw_test_opt((info)->mount_opt, opt)) { \
2178 btrfs_info((info), fmt, ##args); \
2179 btrfs_set_pending((info), CLEAR_##opt); \
2180 btrfs_clear_pending((info), SET_##opt); \
2181 } \
2182} while(0)
2183
2184/*
Yanb98b6762008-01-08 15:54:37 -05002185 * Inode flags
2186 */
Yanfdebe2b2008-01-14 13:26:08 -05002187#define BTRFS_INODE_NODATASUM (1 << 0)
2188#define BTRFS_INODE_NODATACOW (1 << 1)
2189#define BTRFS_INODE_READONLY (1 << 2)
Chris Masonc8b97812008-10-29 14:49:59 -04002190#define BTRFS_INODE_NOCOMPRESS (1 << 3)
Yan Zhengd899e052008-10-30 14:25:28 -04002191#define BTRFS_INODE_PREALLOC (1 << 4)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02002192#define BTRFS_INODE_SYNC (1 << 5)
2193#define BTRFS_INODE_IMMUTABLE (1 << 6)
2194#define BTRFS_INODE_APPEND (1 << 7)
2195#define BTRFS_INODE_NODUMP (1 << 8)
2196#define BTRFS_INODE_NOATIME (1 << 9)
2197#define BTRFS_INODE_DIRSYNC (1 << 10)
Liu Bo75e7cb72011-03-22 10:12:20 +00002198#define BTRFS_INODE_COMPRESS (1 << 11)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02002199
Li Zefan08fe4db2011-03-28 02:01:25 +00002200#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
2201
Chris Masoncfed81a2012-03-03 07:40:03 -05002202struct btrfs_map_token {
2203 struct extent_buffer *eb;
2204 char *kaddr;
2205 unsigned long offset;
2206};
2207
2208static inline void btrfs_init_map_token (struct btrfs_map_token *token)
2209{
Josef Bacikad914552012-10-15 13:39:33 -04002210 token->kaddr = NULL;
Chris Masoncfed81a2012-03-03 07:40:03 -05002211}
2212
Chris Mason5f39d392007-10-15 16:14:19 -04002213/* some macros to generate set/get funcs for the struct fields. This
2214 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
2215 * one for u8:
2216 */
2217#define le8_to_cpu(v) (v)
2218#define cpu_to_le8(v) (v)
2219#define __le8 u8
Chris Mason9078a3e2007-04-26 16:46:15 -04002220
Chris Mason5f39d392007-10-15 16:14:19 -04002221#define read_eb_member(eb, ptr, type, member, result) ( \
2222 read_extent_buffer(eb, (char *)(result), \
2223 ((unsigned long)(ptr)) + \
2224 offsetof(type, member), \
2225 sizeof(((type *)0)->member)))
2226
2227#define write_eb_member(eb, ptr, type, member, result) ( \
2228 write_extent_buffer(eb, (char *)(result), \
2229 ((unsigned long)(ptr)) + \
2230 offsetof(type, member), \
2231 sizeof(((type *)0)->member)))
2232
Li Zefan18077bb2012-07-09 20:22:35 -06002233#define DECLARE_BTRFS_SETGET_BITS(bits) \
2234u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr, \
2235 unsigned long off, \
2236 struct btrfs_map_token *token); \
2237void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr, \
2238 unsigned long off, u##bits val, \
2239 struct btrfs_map_token *token); \
2240static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \
2241 unsigned long off) \
2242{ \
2243 return btrfs_get_token_##bits(eb, ptr, off, NULL); \
2244} \
2245static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \
2246 unsigned long off, u##bits val) \
2247{ \
2248 btrfs_set_token_##bits(eb, ptr, off, val, NULL); \
2249}
2250
2251DECLARE_BTRFS_SETGET_BITS(8)
2252DECLARE_BTRFS_SETGET_BITS(16)
2253DECLARE_BTRFS_SETGET_BITS(32)
2254DECLARE_BTRFS_SETGET_BITS(64)
2255
Chris Mason5f39d392007-10-15 16:14:19 -04002256#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
Li Zefan18077bb2012-07-09 20:22:35 -06002257static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s) \
2258{ \
2259 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2260 return btrfs_get_##bits(eb, s, offsetof(type, member)); \
2261} \
2262static inline void btrfs_set_##name(struct extent_buffer *eb, type *s, \
2263 u##bits val) \
2264{ \
2265 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2266 btrfs_set_##bits(eb, s, offsetof(type, member), val); \
2267} \
2268static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \
2269 struct btrfs_map_token *token) \
2270{ \
2271 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2272 return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
2273} \
2274static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
2275 type *s, u##bits val, \
2276 struct btrfs_map_token *token) \
2277{ \
2278 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
2279 btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
2280}
Chris Mason9078a3e2007-04-26 16:46:15 -04002281
Chris Mason5f39d392007-10-15 16:14:19 -04002282#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
2283static inline u##bits btrfs_##name(struct extent_buffer *eb) \
2284{ \
Chris Mason727011e2010-08-06 13:21:20 -04002285 type *p = page_address(eb->pages[0]); \
David Millerdf68b8a2008-02-15 10:40:52 -05002286 u##bits res = le##bits##_to_cpu(p->member); \
Chris Mason810191f2007-10-15 16:18:55 -04002287 return res; \
Chris Mason5f39d392007-10-15 16:14:19 -04002288} \
2289static inline void btrfs_set_##name(struct extent_buffer *eb, \
2290 u##bits val) \
2291{ \
Chris Mason727011e2010-08-06 13:21:20 -04002292 type *p = page_address(eb->pages[0]); \
David Millerdf68b8a2008-02-15 10:40:52 -05002293 p->member = cpu_to_le##bits(val); \
Chris Mason9078a3e2007-04-26 16:46:15 -04002294}
Chris Mason1e1d2702007-03-15 19:03:33 -04002295
Chris Mason5f39d392007-10-15 16:14:19 -04002296#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
2297static inline u##bits btrfs_##name(type *s) \
2298{ \
2299 return le##bits##_to_cpu(s->member); \
2300} \
2301static inline void btrfs_set_##name(type *s, u##bits val) \
2302{ \
2303 s->member = cpu_to_le##bits(val); \
Chris Mason1e1d2702007-03-15 19:03:33 -04002304}
2305
Chris Mason0b86a832008-03-24 15:01:56 -04002306BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
2307BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
2308BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
2309BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
2310BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
Chris Masonc3027eb2008-12-08 16:40:21 -05002311BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
2312 start_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002313BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
2314BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04002315BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
2316BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
2317BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05002318BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002319
Chris Mason8a4b83c2008-03-24 15:02:07 -04002320BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
2321BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
2322 total_bytes, 64);
2323BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
2324 bytes_used, 64);
2325BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
2326 io_align, 32);
2327BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
2328 io_width, 32);
2329BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
2330 sector_size, 32);
2331BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04002332BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
2333 dev_group, 32);
2334BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
2335 seek_speed, 8);
2336BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
2337 bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05002338BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
2339 generation, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04002340
Geert Uytterhoeven410ba3a2013-08-20 13:20:11 +02002341static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
Chris Mason0b86a832008-03-24 15:01:56 -04002342{
Geert Uytterhoeven410ba3a2013-08-20 13:20:11 +02002343 return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
Chris Mason0b86a832008-03-24 15:01:56 -04002344}
2345
Geert Uytterhoeven1473b242013-08-20 13:20:12 +02002346static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
Yan Zheng2b820322008-11-17 21:11:30 -05002347{
Geert Uytterhoeven1473b242013-08-20 13:20:12 +02002348 return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
Yan Zheng2b820322008-11-17 21:11:30 -05002349}
2350
Chris Masone17cade2008-04-15 15:41:47 -04002351BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002352BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
2353BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
2354BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
2355BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
2356BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
2357BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
2358BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04002359BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04002360BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
2361BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
2362
Chris Masone17cade2008-04-15 15:41:47 -04002363static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
2364{
2365 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
2366}
2367
2368BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002369BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
2370BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
2371 stripe_len, 64);
2372BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
2373 io_align, 32);
2374BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
2375 io_width, 32);
2376BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
2377 sector_size, 32);
2378BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
2379BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
2380 num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04002381BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
2382 sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04002383BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
2384BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
2385
2386static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
2387 int nr)
2388{
2389 unsigned long offset = (unsigned long)c;
2390 offset += offsetof(struct btrfs_chunk, stripe);
2391 offset += nr * sizeof(struct btrfs_stripe);
2392 return (struct btrfs_stripe *)offset;
2393}
2394
Chris Masona4437552008-04-18 10:29:38 -04002395static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
2396{
2397 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
2398}
2399
Chris Mason0b86a832008-03-24 15:01:56 -04002400static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
2401 struct btrfs_chunk *c, int nr)
2402{
2403 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
2404}
2405
Chris Mason0b86a832008-03-24 15:01:56 -04002406static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
2407 struct btrfs_chunk *c, int nr)
2408{
2409 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
2410}
2411
Chris Mason5f39d392007-10-15 16:14:19 -04002412/* struct btrfs_block_group_item */
2413BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
2414 used, 64);
2415BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
2416 used, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002417BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
2418 struct btrfs_block_group_item, chunk_objectid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04002419
2420BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
Chris Mason0b86a832008-03-24 15:01:56 -04002421 struct btrfs_block_group_item, chunk_objectid, 64);
2422BTRFS_SETGET_FUNCS(disk_block_group_flags,
2423 struct btrfs_block_group_item, flags, 64);
2424BTRFS_SETGET_STACK_FUNCS(block_group_flags,
2425 struct btrfs_block_group_item, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002426
Chris Mason39544012007-12-12 14:38:19 -05002427/* struct btrfs_inode_ref */
2428BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
Josef Bacikaec74772008-07-24 12:12:38 -04002429BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
Chris Mason39544012007-12-12 14:38:19 -05002430
Mark Fashehf1863732012-08-08 11:32:27 -07002431/* struct btrfs_inode_extref */
2432BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
2433 parent_objectid, 64);
2434BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
2435 name_len, 16);
2436BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
2437
Chris Mason5f39d392007-10-15 16:14:19 -04002438/* struct btrfs_inode_item */
2439BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05002440BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
Chris Masone02119d2008-09-05 16:13:11 -04002441BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002442BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
Yan Zhenga76a3cd2008-10-09 11:46:29 -04002443BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002444BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
2445BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
2446BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
2447BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
2448BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
Chris Mason0b86a832008-03-24 15:01:56 -04002449BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002450BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002451BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
2452 generation, 64);
2453BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
2454 sequence, 64);
2455BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
2456 transid, 64);
2457BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
2458BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
2459 nbytes, 64);
2460BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
2461 block_group, 64);
2462BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
2463BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
2464BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
2465BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
2466BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
2467BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002468
Chris Mason0b86a832008-03-24 15:01:56 -04002469static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04002470btrfs_inode_atime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04002471{
Chris Mason5f39d392007-10-15 16:14:19 -04002472 unsigned long ptr = (unsigned long)inode_item;
2473 ptr += offsetof(struct btrfs_inode_item, atime);
Chris Mason0b86a832008-03-24 15:01:56 -04002474 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04002475}
2476
Chris Mason0b86a832008-03-24 15:01:56 -04002477static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04002478btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04002479{
Chris Mason5f39d392007-10-15 16:14:19 -04002480 unsigned long ptr = (unsigned long)inode_item;
2481 ptr += offsetof(struct btrfs_inode_item, mtime);
Chris Mason0b86a832008-03-24 15:01:56 -04002482 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04002483}
2484
Chris Mason0b86a832008-03-24 15:01:56 -04002485static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04002486btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04002487{
Chris Mason5f39d392007-10-15 16:14:19 -04002488 unsigned long ptr = (unsigned long)inode_item;
2489 ptr += offsetof(struct btrfs_inode_item, ctime);
Chris Mason0b86a832008-03-24 15:01:56 -04002490 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04002491}
2492
Chris Mason0b86a832008-03-24 15:01:56 -04002493BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
2494BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002495BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
2496BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002497
Chris Mason0b86a832008-03-24 15:01:56 -04002498/* struct btrfs_dev_extent */
Chris Masone17cade2008-04-15 15:41:47 -04002499BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
2500 chunk_tree, 64);
2501BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
2502 chunk_objectid, 64);
2503BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
2504 chunk_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002505BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
2506
Geert Uytterhoeven231e88f2013-08-20 13:20:13 +02002507static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
Chris Masone17cade2008-04-15 15:41:47 -04002508{
2509 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
Geert Uytterhoeven231e88f2013-08-20 13:20:13 +02002510 return (unsigned long)dev + ptr;
Chris Masone17cade2008-04-15 15:41:47 -04002511}
2512
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002513BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
2514BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
2515 generation, 64);
2516BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
Chris Mason74493f72007-12-11 09:25:06 -05002517
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002518BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002519
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002520
2521BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
2522
2523static inline void btrfs_tree_block_key(struct extent_buffer *eb,
2524 struct btrfs_tree_block_info *item,
2525 struct btrfs_disk_key *key)
2526{
2527 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2528}
2529
2530static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
2531 struct btrfs_tree_block_info *item,
2532 struct btrfs_disk_key *key)
2533{
2534 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2535}
2536
2537BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
2538 root, 64);
2539BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
2540 objectid, 64);
2541BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
2542 offset, 64);
2543BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
2544 count, 32);
2545
2546BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
2547 count, 32);
2548
2549BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
2550 type, 8);
2551BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
2552 offset, 64);
2553
2554static inline u32 btrfs_extent_inline_ref_size(int type)
2555{
2556 if (type == BTRFS_TREE_BLOCK_REF_KEY ||
2557 type == BTRFS_SHARED_BLOCK_REF_KEY)
2558 return sizeof(struct btrfs_extent_inline_ref);
2559 if (type == BTRFS_SHARED_DATA_REF_KEY)
2560 return sizeof(struct btrfs_shared_data_ref) +
2561 sizeof(struct btrfs_extent_inline_ref);
2562 if (type == BTRFS_EXTENT_DATA_REF_KEY)
2563 return sizeof(struct btrfs_extent_data_ref) +
2564 offsetof(struct btrfs_extent_inline_ref, offset);
2565 BUG();
2566 return 0;
2567}
2568
2569BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
2570BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
2571 generation, 64);
2572BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
2573BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002574
2575/* struct btrfs_node */
2576BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
Chris Mason74493f72007-12-11 09:25:06 -05002577BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002578BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
2579 blockptr, 64);
2580BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
2581 generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002582
2583static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002584{
Chris Mason5f39d392007-10-15 16:14:19 -04002585 unsigned long ptr;
2586 ptr = offsetof(struct btrfs_node, ptrs) +
2587 sizeof(struct btrfs_key_ptr) * nr;
2588 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
Chris Mason1e1d2702007-03-15 19:03:33 -04002589}
2590
Chris Mason5f39d392007-10-15 16:14:19 -04002591static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
2592 int nr, u64 val)
Chris Mason31f3c992007-04-30 15:25:45 -04002593{
Chris Mason5f39d392007-10-15 16:14:19 -04002594 unsigned long ptr;
2595 ptr = offsetof(struct btrfs_node, ptrs) +
2596 sizeof(struct btrfs_key_ptr) * nr;
2597 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
Chris Mason31f3c992007-04-30 15:25:45 -04002598}
2599
Chris Mason74493f72007-12-11 09:25:06 -05002600static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
2601{
2602 unsigned long ptr;
2603 ptr = offsetof(struct btrfs_node, ptrs) +
2604 sizeof(struct btrfs_key_ptr) * nr;
2605 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
2606}
2607
2608static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
2609 int nr, u64 val)
2610{
2611 unsigned long ptr;
2612 ptr = offsetof(struct btrfs_node, ptrs) +
2613 sizeof(struct btrfs_key_ptr) * nr;
2614 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
2615}
2616
Chris Mason810191f2007-10-15 16:18:55 -04002617static inline unsigned long btrfs_node_key_ptr_offset(int nr)
Chris Mason31f3c992007-04-30 15:25:45 -04002618{
Chris Mason5f39d392007-10-15 16:14:19 -04002619 return offsetof(struct btrfs_node, ptrs) +
2620 sizeof(struct btrfs_key_ptr) * nr;
Chris Mason31f3c992007-04-30 15:25:45 -04002621}
2622
Chris Masone644d022007-11-06 15:09:29 -05002623void btrfs_node_key(struct extent_buffer *eb,
2624 struct btrfs_disk_key *disk_key, int nr);
2625
Chris Mason5f39d392007-10-15 16:14:19 -04002626static inline void btrfs_set_node_key(struct extent_buffer *eb,
2627 struct btrfs_disk_key *disk_key, int nr)
2628{
2629 unsigned long ptr;
2630 ptr = btrfs_node_key_ptr_offset(nr);
2631 write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
2632 struct btrfs_key_ptr, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04002633}
2634
Chris Mason5f39d392007-10-15 16:14:19 -04002635/* struct btrfs_item */
2636BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
2637BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002638BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
2639BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002640
2641static inline unsigned long btrfs_item_nr_offset(int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002642{
Chris Mason5f39d392007-10-15 16:14:19 -04002643 return offsetof(struct btrfs_leaf, items) +
2644 sizeof(struct btrfs_item) * nr;
Chris Mason1e1d2702007-03-15 19:03:33 -04002645}
2646
Ross Kirkdd3cc162013-09-16 15:58:09 +01002647static inline struct btrfs_item *btrfs_item_nr(int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002648{
Chris Mason5f39d392007-10-15 16:14:19 -04002649 return (struct btrfs_item *)btrfs_item_nr_offset(nr);
Chris Mason1e1d2702007-03-15 19:03:33 -04002650}
2651
Chris Mason5f39d392007-10-15 16:14:19 -04002652static inline u32 btrfs_item_end(struct extent_buffer *eb,
2653 struct btrfs_item *item)
Chris Mason1e1d2702007-03-15 19:03:33 -04002654{
Chris Mason5f39d392007-10-15 16:14:19 -04002655 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
Chris Mason1e1d2702007-03-15 19:03:33 -04002656}
2657
Chris Mason5f39d392007-10-15 16:14:19 -04002658static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002659{
Ross Kirkdd3cc162013-09-16 15:58:09 +01002660 return btrfs_item_end(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04002661}
2662
Chris Mason5f39d392007-10-15 16:14:19 -04002663static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002664{
Ross Kirkdd3cc162013-09-16 15:58:09 +01002665 return btrfs_item_offset(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04002666}
2667
Chris Mason5f39d392007-10-15 16:14:19 -04002668static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002669{
Ross Kirkdd3cc162013-09-16 15:58:09 +01002670 return btrfs_item_size(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04002671}
2672
Chris Mason5f39d392007-10-15 16:14:19 -04002673static inline void btrfs_item_key(struct extent_buffer *eb,
2674 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002675{
Ross Kirkdd3cc162013-09-16 15:58:09 +01002676 struct btrfs_item *item = btrfs_item_nr(nr);
Chris Mason5f39d392007-10-15 16:14:19 -04002677 read_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04002678}
2679
Chris Mason5f39d392007-10-15 16:14:19 -04002680static inline void btrfs_set_item_key(struct extent_buffer *eb,
2681 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04002682{
Ross Kirkdd3cc162013-09-16 15:58:09 +01002683 struct btrfs_item *item = btrfs_item_nr(nr);
Chris Mason5f39d392007-10-15 16:14:19 -04002684 write_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04002685}
2686
Chris Masone02119d2008-09-05 16:13:11 -04002687BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
2688
Chris Mason0660b5a2008-11-17 20:37:39 -05002689/*
2690 * struct btrfs_root_ref
2691 */
2692BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
2693BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
2694BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
2695
Chris Mason5f39d392007-10-15 16:14:19 -04002696/* struct btrfs_dir_item */
Josef Bacik5103e942007-11-16 11:45:54 -05002697BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
Chris Mason5f39d392007-10-15 16:14:19 -04002698BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
2699BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
Chris Masone02119d2008-09-05 16:13:11 -04002700BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002701BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
2702BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
2703 data_len, 16);
2704BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
2705 name_len, 16);
2706BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
2707 transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002708
2709static inline void btrfs_dir_item_key(struct extent_buffer *eb,
2710 struct btrfs_dir_item *item,
2711 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04002712{
Chris Mason5f39d392007-10-15 16:14:19 -04002713 read_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04002714}
2715
Chris Mason5f39d392007-10-15 16:14:19 -04002716static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
2717 struct btrfs_dir_item *item,
2718 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04002719{
Chris Mason5f39d392007-10-15 16:14:19 -04002720 write_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04002721}
2722
Josef Bacik0af3d002010-06-21 14:48:16 -04002723BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
2724 num_entries, 64);
2725BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
2726 num_bitmaps, 64);
2727BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
2728 generation, 64);
2729
2730static inline void btrfs_free_space_key(struct extent_buffer *eb,
2731 struct btrfs_free_space_header *h,
2732 struct btrfs_disk_key *key)
2733{
2734 read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2735}
2736
2737static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
2738 struct btrfs_free_space_header *h,
2739 struct btrfs_disk_key *key)
2740{
2741 write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2742}
2743
Chris Mason5f39d392007-10-15 16:14:19 -04002744/* struct btrfs_disk_key */
2745BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
2746 objectid, 64);
2747BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2748BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
Chris Mason1d4f6402007-03-15 15:18:43 -04002749
Chris Masone2fa7222007-03-12 16:22:34 -04002750static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2751 struct btrfs_disk_key *disk)
2752{
2753 cpu->offset = le64_to_cpu(disk->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04002754 cpu->type = disk->type;
Chris Masone2fa7222007-03-12 16:22:34 -04002755 cpu->objectid = le64_to_cpu(disk->objectid);
2756}
2757
2758static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
2759 struct btrfs_key *cpu)
2760{
2761 disk->offset = cpu_to_le64(cpu->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04002762 disk->type = cpu->type;
Chris Masone2fa7222007-03-12 16:22:34 -04002763 disk->objectid = cpu_to_le64(cpu->objectid);
2764}
2765
Chris Mason5f39d392007-10-15 16:14:19 -04002766static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
2767 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04002768{
Chris Mason5f39d392007-10-15 16:14:19 -04002769 struct btrfs_disk_key disk_key;
2770 btrfs_node_key(eb, &disk_key, nr);
2771 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002772}
2773
Chris Mason5f39d392007-10-15 16:14:19 -04002774static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
2775 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04002776{
Chris Mason5f39d392007-10-15 16:14:19 -04002777 struct btrfs_disk_key disk_key;
2778 btrfs_item_key(eb, &disk_key, nr);
2779 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002780}
2781
Chris Mason5f39d392007-10-15 16:14:19 -04002782static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
2783 struct btrfs_dir_item *item,
2784 struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04002785{
Chris Mason5f39d392007-10-15 16:14:19 -04002786 struct btrfs_disk_key disk_key;
2787 btrfs_dir_item_key(eb, item, &disk_key);
2788 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002789}
2790
Chris Mason5f39d392007-10-15 16:14:19 -04002791
2792static inline u8 btrfs_key_type(struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04002793{
Chris Mason5f39d392007-10-15 16:14:19 -04002794 return key->type;
Chris Masone2fa7222007-03-12 16:22:34 -04002795}
2796
Chris Mason5f39d392007-10-15 16:14:19 -04002797static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
Chris Masone2fa7222007-03-12 16:22:34 -04002798{
Chris Mason5f39d392007-10-15 16:14:19 -04002799 key->type = val;
Chris Masone2fa7222007-03-12 16:22:34 -04002800}
2801
Chris Mason5f39d392007-10-15 16:14:19 -04002802/* struct btrfs_header */
Chris Masondb945352007-10-15 16:15:53 -04002803BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002804BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2805 generation, 64);
2806BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2807BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
Chris Mason63b10fc2008-04-01 11:21:32 -04002808BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002809BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002810BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
2811 generation, 64);
2812BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
2813BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
2814 nritems, 32);
2815BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002816
Chris Mason63b10fc2008-04-01 11:21:32 -04002817static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
2818{
2819 return (btrfs_header_flags(eb) & flag) == flag;
2820}
2821
2822static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2823{
2824 u64 flags = btrfs_header_flags(eb);
2825 btrfs_set_header_flags(eb, flags | flag);
2826 return (flags & flag) == flag;
2827}
2828
2829static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2830{
2831 u64 flags = btrfs_header_flags(eb);
2832 btrfs_set_header_flags(eb, flags & ~flag);
2833 return (flags & flag) == flag;
2834}
2835
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002836static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
2837{
2838 u64 flags = btrfs_header_flags(eb);
2839 return flags >> BTRFS_BACKREF_REV_SHIFT;
2840}
2841
2842static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2843 int rev)
2844{
2845 u64 flags = btrfs_header_flags(eb);
2846 flags &= ~BTRFS_BACKREF_REV_MASK;
2847 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2848 btrfs_set_header_flags(eb, flags);
2849}
2850
Ross Kirk0a4e5582013-09-24 10:12:38 +01002851static inline unsigned long btrfs_header_fsid(void)
Chris Masone2fa7222007-03-12 16:22:34 -04002852{
Geert Uytterhoevenfba6aa72013-08-20 13:20:14 +02002853 return offsetof(struct btrfs_header, fsid);
Chris Masone2fa7222007-03-12 16:22:34 -04002854}
2855
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02002856static inline unsigned long btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
Chris Masone17cade2008-04-15 15:41:47 -04002857{
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02002858 return offsetof(struct btrfs_header, chunk_tree_uuid);
Chris Masone17cade2008-04-15 15:41:47 -04002859}
2860
Chris Mason5f39d392007-10-15 16:14:19 -04002861static inline int btrfs_is_leaf(struct extent_buffer *eb)
Chris Mason7518a232007-03-12 12:01:18 -04002862{
Chris Masond3977122009-01-05 21:25:51 -05002863 return btrfs_header_level(eb) == 0;
Chris Mason7518a232007-03-12 12:01:18 -04002864}
2865
Chris Mason5f39d392007-10-15 16:14:19 -04002866/* struct btrfs_root_item */
Yan Zheng84234f32008-10-29 14:49:05 -04002867BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2868 generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002869BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
Chris Masondb945352007-10-15 16:15:53 -04002870BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2871BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002872
Yan Zheng84234f32008-10-29 14:49:05 -04002873BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2874 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002875BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2876BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002877BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2878BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002879BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
Chris Masondb945352007-10-15 16:15:53 -04002880BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2881BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
Yan Zheng80ff3852008-10-30 14:20:02 -04002882BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2883 last_snapshot, 64);
Alexander Block8ea05e32012-07-25 17:35:53 +02002884BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2885 generation_v2, 64);
2886BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2887 ctransid, 64);
2888BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2889 otransid, 64);
2890BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2891 stransid, 64);
2892BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2893 rtransid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002894
Li Zefanb83cc962010-12-20 16:04:08 +08002895static inline bool btrfs_root_readonly(struct btrfs_root *root)
2896{
Al Viro6ed3cf22012-04-13 11:49:04 -04002897 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
Li Zefanb83cc962010-12-20 16:04:08 +08002898}
2899
David Sterba521e0542014-04-15 16:41:44 +02002900static inline bool btrfs_root_dead(struct btrfs_root *root)
2901{
2902 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
2903}
2904
Chris Masonaf31f5e2011-11-03 15:17:42 -04002905/* struct btrfs_root_backup */
2906BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2907 tree_root, 64);
2908BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2909 tree_root_gen, 64);
2910BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2911 tree_root_level, 8);
2912
2913BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2914 chunk_root, 64);
2915BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2916 chunk_root_gen, 64);
2917BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2918 chunk_root_level, 8);
2919
2920BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2921 extent_root, 64);
2922BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2923 extent_root_gen, 64);
2924BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2925 extent_root_level, 8);
2926
2927BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2928 fs_root, 64);
2929BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2930 fs_root_gen, 64);
2931BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2932 fs_root_level, 8);
2933
2934BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2935 dev_root, 64);
2936BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2937 dev_root_gen, 64);
2938BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2939 dev_root_level, 8);
2940
2941BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2942 csum_root, 64);
2943BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2944 csum_root_gen, 64);
2945BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2946 csum_root_level, 8);
2947BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2948 total_bytes, 64);
2949BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2950 bytes_used, 64);
2951BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2952 num_devices, 64);
2953
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002954/* struct btrfs_balance_item */
2955BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002956
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002957static inline void btrfs_balance_data(struct extent_buffer *eb,
2958 struct btrfs_balance_item *bi,
2959 struct btrfs_disk_balance_args *ba)
2960{
2961 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2962}
2963
2964static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2965 struct btrfs_balance_item *bi,
2966 struct btrfs_disk_balance_args *ba)
2967{
2968 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2969}
2970
2971static inline void btrfs_balance_meta(struct extent_buffer *eb,
2972 struct btrfs_balance_item *bi,
2973 struct btrfs_disk_balance_args *ba)
2974{
2975 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2976}
2977
2978static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2979 struct btrfs_balance_item *bi,
2980 struct btrfs_disk_balance_args *ba)
2981{
2982 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2983}
2984
2985static inline void btrfs_balance_sys(struct extent_buffer *eb,
2986 struct btrfs_balance_item *bi,
2987 struct btrfs_disk_balance_args *ba)
2988{
2989 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2990}
2991
2992static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2993 struct btrfs_balance_item *bi,
2994 struct btrfs_disk_balance_args *ba)
2995{
2996 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2997}
2998
2999static inline void
3000btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
3001 struct btrfs_disk_balance_args *disk)
3002{
3003 memset(cpu, 0, sizeof(*cpu));
3004
3005 cpu->profiles = le64_to_cpu(disk->profiles);
3006 cpu->usage = le64_to_cpu(disk->usage);
3007 cpu->devid = le64_to_cpu(disk->devid);
3008 cpu->pstart = le64_to_cpu(disk->pstart);
3009 cpu->pend = le64_to_cpu(disk->pend);
3010 cpu->vstart = le64_to_cpu(disk->vstart);
3011 cpu->vend = le64_to_cpu(disk->vend);
3012 cpu->target = le64_to_cpu(disk->target);
3013 cpu->flags = le64_to_cpu(disk->flags);
David Sterba7d824b62014-05-07 17:37:51 +02003014 cpu->limit = le64_to_cpu(disk->limit);
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02003015}
3016
3017static inline void
3018btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
3019 struct btrfs_balance_args *cpu)
3020{
3021 memset(disk, 0, sizeof(*disk));
3022
3023 disk->profiles = cpu_to_le64(cpu->profiles);
3024 disk->usage = cpu_to_le64(cpu->usage);
3025 disk->devid = cpu_to_le64(cpu->devid);
3026 disk->pstart = cpu_to_le64(cpu->pstart);
3027 disk->pend = cpu_to_le64(cpu->pend);
3028 disk->vstart = cpu_to_le64(cpu->vstart);
3029 disk->vend = cpu_to_le64(cpu->vend);
3030 disk->target = cpu_to_le64(cpu->target);
3031 disk->flags = cpu_to_le64(cpu->flags);
David Sterba7d824b62014-05-07 17:37:51 +02003032 disk->limit = cpu_to_le64(cpu->limit);
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02003033}
3034
3035/* struct btrfs_super_block */
Chris Masondb945352007-10-15 16:15:53 -04003036BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
Chris Masona061fc82008-05-07 11:43:44 -04003037BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04003038BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
3039 generation, 64);
3040BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04003041BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
3042 struct btrfs_super_block, sys_chunk_array_size, 32);
Yan Zheng84234f32008-10-29 14:49:05 -04003043BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
3044 struct btrfs_super_block, chunk_root_generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04003045BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
3046 root_level, 8);
Chris Mason0b86a832008-03-24 15:01:56 -04003047BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
3048 chunk_root, 64);
3049BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
Chris Masone02119d2008-09-05 16:13:11 -04003050 chunk_root_level, 8);
3051BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
3052 log_root, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05003053BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
3054 log_root_transid, 64);
Chris Masone02119d2008-09-05 16:13:11 -04003055BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
3056 log_root_level, 8);
Chris Masondb945352007-10-15 16:15:53 -04003057BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
3058 total_bytes, 64);
3059BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
3060 bytes_used, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04003061BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
3062 sectorsize, 32);
3063BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
3064 nodesize, 32);
Chris Mason87ee04e2007-11-30 11:30:34 -05003065BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
3066 stripesize, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04003067BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
3068 root_dir_objectid, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04003069BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
3070 num_devices, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05003071BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
3072 compat_flags, 64);
3073BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
Josef Bacik12534832009-12-17 21:32:27 +00003074 compat_ro_flags, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05003075BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
3076 incompat_flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05003077BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
3078 csum_type, 16);
Josef Bacik0af3d002010-06-21 14:48:16 -04003079BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
3080 cache_generation, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08003081BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
Stefan Behrens26432792013-08-15 17:11:22 +02003082BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
3083 uuid_tree_generation, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05003084
3085static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
3086{
David Sterba1104a882013-03-06 15:57:46 +01003087 u16 t = btrfs_super_csum_type(s);
3088 /*
3089 * csum type is validated at mount time
3090 */
Josef Bacik607d4322008-12-02 07:17:45 -05003091 return btrfs_csum_sizes[t];
3092}
Chris Mason5f39d392007-10-15 16:14:19 -04003093
3094static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
Chris Mason7f5c1512007-03-23 15:56:19 -04003095{
Chris Mason5f39d392007-10-15 16:14:19 -04003096 return offsetof(struct btrfs_leaf, items);
Chris Mason7f5c1512007-03-23 15:56:19 -04003097}
3098
Chris Mason5f39d392007-10-15 16:14:19 -04003099/* struct btrfs_file_extent_item */
3100BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
Qu Wenruo3cae2102013-07-16 11:19:18 +08003101BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
3102 struct btrfs_file_extent_item, disk_bytenr, 64);
3103BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
3104 struct btrfs_file_extent_item, offset, 64);
3105BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
3106 struct btrfs_file_extent_item, generation, 64);
3107BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
3108 struct btrfs_file_extent_item, num_bytes, 64);
Josef Bacike20d6c52013-11-13 21:11:49 -05003109BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
3110 struct btrfs_file_extent_item, disk_num_bytes, 64);
3111BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
3112 struct btrfs_file_extent_item, compression, 8);
Chris Mason7f5c1512007-03-23 15:56:19 -04003113
Chris Masond3977122009-01-05 21:25:51 -05003114static inline unsigned long
3115btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
Chris Mason236454d2007-04-19 13:37:44 -04003116{
David Sterba7ec20af2014-07-24 17:34:58 +02003117 return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
Chris Mason236454d2007-04-19 13:37:44 -04003118}
3119
3120static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
3121{
David Sterba7ec20af2014-07-24 17:34:58 +02003122 return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
Chris Mason236454d2007-04-19 13:37:44 -04003123}
3124
Chris Masondb945352007-10-15 16:15:53 -04003125BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
3126 disk_bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04003127BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
3128 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04003129BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
3130 disk_num_bytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04003131BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
3132 offset, 64);
Chris Masondb945352007-10-15 16:15:53 -04003133BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
3134 num_bytes, 64);
Chris Masonc8b97812008-10-29 14:49:59 -04003135BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
3136 ram_bytes, 64);
3137BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
3138 compression, 8);
3139BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
3140 encryption, 8);
3141BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
3142 other_encoding, 16);
3143
Chris Masonc8b97812008-10-29 14:49:59 -04003144/*
3145 * this returns the number of bytes used by the item on disk, minus the
3146 * size of any extent headers. If a file is compressed on disk, this is
3147 * the compressed size
3148 */
3149static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
3150 struct btrfs_item *e)
3151{
David Sterba7ec20af2014-07-24 17:34:58 +02003152 return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
Chris Masonc8b97812008-10-29 14:49:59 -04003153}
Chris Mason9f5fae22007-03-20 14:38:32 -04003154
Chris Mason514ac8a2014-01-03 21:07:00 -08003155/* this returns the number of file bytes represented by the inline item.
3156 * If an item is compressed, this is the uncompressed size
3157 */
3158static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
3159 int slot,
3160 struct btrfs_file_extent_item *fi)
3161{
3162 struct btrfs_map_token token;
3163
3164 btrfs_init_map_token(&token);
3165 /*
3166 * return the space used on disk if this item isn't
3167 * compressed or encoded
3168 */
3169 if (btrfs_token_file_extent_compression(eb, fi, &token) == 0 &&
3170 btrfs_token_file_extent_encryption(eb, fi, &token) == 0 &&
3171 btrfs_token_file_extent_other_encoding(eb, fi, &token) == 0) {
3172 return btrfs_file_extent_inline_item_len(eb,
3173 btrfs_item_nr(slot));
3174 }
3175
3176 /* otherwise use the ram bytes field */
3177 return btrfs_token_file_extent_ram_bytes(eb, fi, &token);
3178}
3179
3180
Stefan Behrens733f4fb2012-05-25 16:06:10 +02003181/* btrfs_dev_stats_item */
3182static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb,
3183 struct btrfs_dev_stats_item *ptr,
3184 int index)
3185{
3186 u64 val;
3187
3188 read_extent_buffer(eb, &val,
3189 offsetof(struct btrfs_dev_stats_item, values) +
3190 ((unsigned long)ptr) + (index * sizeof(u64)),
3191 sizeof(val));
3192 return val;
3193}
3194
3195static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
3196 struct btrfs_dev_stats_item *ptr,
3197 int index, u64 val)
3198{
3199 write_extent_buffer(eb, &val,
3200 offsetof(struct btrfs_dev_stats_item, values) +
3201 ((unsigned long)ptr) + (index * sizeof(u64)),
3202 sizeof(val));
3203}
3204
Arne Jansen630dc772011-09-13 11:06:07 +02003205/* btrfs_qgroup_status_item */
3206BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
3207 generation, 64);
3208BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
3209 version, 64);
3210BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
3211 flags, 64);
Jan Schmidt2f232032013-04-25 16:04:51 +00003212BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
3213 rescan, 64);
Arne Jansen630dc772011-09-13 11:06:07 +02003214
3215/* btrfs_qgroup_info_item */
3216BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
3217 generation, 64);
3218BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
3219BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
3220 rfer_cmpr, 64);
3221BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
3222BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
3223 excl_cmpr, 64);
3224
3225BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
3226 struct btrfs_qgroup_info_item, generation, 64);
3227BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
3228 rfer, 64);
3229BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
3230 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
3231BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
3232 excl, 64);
3233BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
3234 struct btrfs_qgroup_info_item, excl_cmpr, 64);
3235
3236/* btrfs_qgroup_limit_item */
3237BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
3238 flags, 64);
3239BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
3240 max_rfer, 64);
3241BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
3242 max_excl, 64);
3243BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
3244 rsv_rfer, 64);
3245BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
3246 rsv_excl, 64);
3247
Stefan Behrensa2bff642012-11-05 17:32:20 +01003248/* btrfs_dev_replace_item */
3249BTRFS_SETGET_FUNCS(dev_replace_src_devid,
3250 struct btrfs_dev_replace_item, src_devid, 64);
3251BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
3252 struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
3253 64);
3254BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
3255 replace_state, 64);
3256BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
3257 time_started, 64);
3258BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
3259 time_stopped, 64);
3260BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
3261 num_write_errors, 64);
3262BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
3263 struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
3264 64);
3265BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
3266 cursor_left, 64);
3267BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
3268 cursor_right, 64);
3269
3270BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
3271 struct btrfs_dev_replace_item, src_devid, 64);
3272BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
3273 struct btrfs_dev_replace_item,
3274 cont_reading_from_srcdev_mode, 64);
3275BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
3276 struct btrfs_dev_replace_item, replace_state, 64);
3277BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
3278 struct btrfs_dev_replace_item, time_started, 64);
3279BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
3280 struct btrfs_dev_replace_item, time_stopped, 64);
3281BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
3282 struct btrfs_dev_replace_item, num_write_errors, 64);
3283BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
3284 struct btrfs_dev_replace_item,
3285 num_uncorrectable_read_errors, 64);
3286BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
3287 struct btrfs_dev_replace_item, cursor_left, 64);
3288BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
3289 struct btrfs_dev_replace_item, cursor_right, 64);
3290
Al Viro815745c2011-11-17 15:40:49 -05003291static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
Chris Masone20d96d2007-03-22 12:13:20 -04003292{
3293 return sb->s_fs_info;
3294}
3295
Chris Mason4beb1b82007-03-14 10:31:29 -04003296/* helper function to cast into the data area of the leaf. */
3297#define btrfs_item_ptr(leaf, slot, type) \
Chris Mason123abc82007-03-14 14:14:43 -04003298 ((type *)(btrfs_leaf_data(leaf) + \
Chris Mason5f39d392007-10-15 16:14:19 -04003299 btrfs_item_offset_nr(leaf, slot)))
3300
3301#define btrfs_item_ptr_offset(leaf, slot) \
3302 ((unsigned long)(btrfs_leaf_data(leaf) + \
3303 btrfs_item_offset_nr(leaf, slot)))
Chris Mason4beb1b82007-03-14 10:31:29 -04003304
Josef Bacik67377732010-09-16 16:19:09 -04003305static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
3306{
3307 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
3308 (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
3309}
3310
Josef Bacik3b16a4e2011-09-21 15:05:58 -04003311static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
3312{
3313 return mapping_gfp_mask(mapping) & ~__GFP_FS;
3314}
3315
Chris Masonb18c6682007-04-17 13:26:50 -04003316/* extent-tree.c */
Miao Xie16cdcec2011-04-22 18:12:22 +08003317static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
Josef Bacik9e0baf62011-07-15 15:16:44 +00003318 unsigned num_items)
Miao Xie16cdcec2011-04-22 18:12:22 +08003319{
David Sterba707e8a02014-06-04 19:22:26 +02003320 return (root->nodesize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
Josef Bacikc4fbb432013-09-17 10:50:06 -04003321 2 * num_items;
Miao Xie16cdcec2011-04-22 18:12:22 +08003322}
3323
Josef Bacik07127182011-08-19 10:29:59 -04003324/*
3325 * Doing a truncate won't result in new nodes or leaves, just what we need for
3326 * COW.
3327 */
3328static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
3329 unsigned num_items)
3330{
David Sterba707e8a02014-06-04 19:22:26 +02003331 return root->nodesize * BTRFS_MAX_LEVEL * num_items;
Josef Bacik07127182011-08-19 10:29:59 -04003332}
3333
Josef Bacik1be41b72013-06-12 13:56:06 -04003334int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
3335 struct btrfs_root *root);
Josef Bacik0a2b2a82014-01-23 10:54:11 -05003336int btrfs_check_space_for_delayed_refs(struct btrfs_trans_handle *trans,
3337 struct btrfs_root *root);
Chris Masonfa9c0d792009-04-03 09:47:43 -04003338void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Chris Mason56bec292009-03-13 10:10:06 -04003339int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
3340 struct btrfs_root *root, unsigned long count);
Chris Masona79b7d42014-05-22 16:18:52 -07003341int btrfs_async_run_delayed_refs(struct btrfs_root *root,
3342 unsigned long count, int wait);
Filipe Manana1a4ed8f2014-10-27 10:44:24 +00003343int btrfs_lookup_data_extent(struct btrfs_root *root, u64 start, u64 len);
Yan, Zhenga22285a2010-05-16 10:48:46 -04003344int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
3345 struct btrfs_root *root, u64 bytenr,
Josef Bacik3173a182013-03-07 14:22:04 -05003346 u64 offset, int metadata, u64 *refs, u64 *flags);
Yan Zheng11833d62009-09-11 16:11:19 -04003347int btrfs_pin_extent(struct btrfs_root *root,
3348 u64 bytenr, u64 num, int reserved);
Liu Bodcfac412012-12-27 09:01:20 +00003349int btrfs_pin_extent_for_log_replay(struct btrfs_root *root,
Chris Masone688b7252011-10-31 20:52:39 -04003350 u64 bytenr, u64 num_bytes);
Josef Bacik8c2a1a32013-06-06 13:19:32 -04003351int btrfs_exclude_logged_extents(struct btrfs_root *root,
3352 struct extent_buffer *eb);
Yan Zheng80ff3852008-10-30 14:20:02 -04003353int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003354 struct btrfs_root *root,
3355 u64 objectid, u64 offset, u64 bytenr);
Chris Masond3977122009-01-05 21:25:51 -05003356struct btrfs_block_group_cache *btrfs_lookup_block_group(
3357 struct btrfs_fs_info *info,
3358 u64 bytenr);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003359void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Jeff Mahoney6ab0a202013-11-01 13:07:04 -04003360int get_block_group_index(struct btrfs_block_group_cache *cache);
David Sterba4d75f8a2014-06-15 01:54:12 +02003361struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
3362 struct btrfs_root *root, u64 parent,
3363 u64 root_objectid,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003364 struct btrfs_disk_key *key, int level,
Jan Schmidt5581a512012-05-16 17:04:52 +02003365 u64 hint, u64 empty_size);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003366void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
3367 struct btrfs_root *root,
3368 struct extent_buffer *buf,
Jan Schmidt5581a512012-05-16 17:04:52 +02003369 u64 parent, int last_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003370int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
3371 struct btrfs_root *root,
3372 u64 root_objectid, u64 owner,
3373 u64 offset, struct btrfs_key *ins);
3374int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
3375 struct btrfs_root *root,
3376 u64 root_objectid, u64 owner, u64 offset,
3377 struct btrfs_key *ins);
Josef Bacik00361582013-08-14 14:02:47 -04003378int btrfs_reserve_extent(struct btrfs_root *root, u64 num_bytes,
3379 u64 min_alloc_size, u64 empty_size, u64 hint_byte,
Miao Xiee570fd22014-06-19 10:42:50 +08003380 struct btrfs_key *ins, int is_data, int delalloc);
Chris Masone089f052007-03-16 16:20:31 -04003381int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Josef Bacike339a6b2014-07-02 10:54:25 -07003382 struct extent_buffer *buf, int full_backref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003383int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Josef Bacike339a6b2014-07-02 10:54:25 -07003384 struct extent_buffer *buf, int full_backref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003385int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
3386 struct btrfs_root *root,
3387 u64 bytenr, u64 num_bytes, u64 flags,
Josef Bacikb1c79e02013-05-09 13:49:30 -04003388 int level, int is_data);
Zheng Yan31840ae2008-09-23 13:14:14 -04003389int btrfs_free_extent(struct btrfs_trans_handle *trans,
3390 struct btrfs_root *root,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02003391 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
Josef Bacikfcebe452014-05-13 17:30:47 -07003392 u64 owner, u64 offset, int no_quota);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003393
Miao Xiee570fd22014-06-19 10:42:50 +08003394int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len,
3395 int delalloc);
Chris Masone688b7252011-10-31 20:52:39 -04003396int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
3397 u64 start, u64 len);
Jeff Mahoney143bede2012-03-01 14:56:26 +01003398void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
3399 struct btrfs_root *root);
Chris Masonccd467d2007-06-28 15:57:36 -04003400int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
Yan Zheng11833d62009-09-11 16:11:19 -04003401 struct btrfs_root *root);
Chris Masonb18c6682007-04-17 13:26:50 -04003402int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Zheng Yan31840ae2008-09-23 13:14:14 -04003403 struct btrfs_root *root,
3404 u64 bytenr, u64 num_bytes, u64 parent,
Josef Bacikfcebe452014-05-13 17:30:47 -07003405 u64 root_objectid, u64 owner, u64 offset, int no_quota);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003406
Chris Mason9078a3e2007-04-26 16:46:15 -04003407int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
3408 struct btrfs_root *root);
Yan Zhengd2fb3432008-12-11 16:30:39 -05003409int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
Chris Mason9078a3e2007-04-26 16:46:15 -04003410int btrfs_free_block_groups(struct btrfs_fs_info *info);
3411int btrfs_read_block_groups(struct btrfs_root *root);
Josef Bacikba1bf482009-09-11 16:11:19 -04003412int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
Chris Mason0b86a832008-03-24 15:01:56 -04003413int btrfs_make_block_group(struct btrfs_trans_handle *trans,
3414 struct btrfs_root *root, u64 bytes_used,
Chris Masone17cade2008-04-15 15:41:47 -04003415 u64 type, u64 chunk_objectid, u64 chunk_offset,
Chris Mason0b86a832008-03-24 15:01:56 -04003416 u64 size);
Zheng Yan1a40e232008-09-26 10:09:34 -04003417int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
Filipe Manana04216822014-11-27 21:14:15 +00003418 struct btrfs_root *root, u64 group_start,
3419 struct extent_map *em);
Josef Bacik47ab2a62014-09-18 11:20:02 -04003420void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);
Josef Bacikea658ba2012-09-11 16:57:25 -04003421void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
3422 struct btrfs_root *root);
Miao Xie6d07bce2011-01-05 10:07:31 +00003423u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
Chris Mason4184ea72009-03-10 12:39:20 -04003424void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
Miao Xie08e007d2012-10-16 11:33:38 +00003425
3426enum btrfs_reserve_flush_enum {
3427 /* If we are in the transaction, we can't flush anything.*/
3428 BTRFS_RESERVE_NO_FLUSH,
3429 /*
3430 * Flushing delalloc may cause deadlock somewhere, in this
3431 * case, use FLUSH LIMIT
3432 */
3433 BTRFS_RESERVE_FLUSH_LIMIT,
3434 BTRFS_RESERVE_FLUSH_ALL,
3435};
3436
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003437int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
3438void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
Yan, Zhenga22285a2010-05-16 10:48:46 -04003439void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
3440 struct btrfs_root *root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04003441int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
3442 struct inode *inode);
3443void btrfs_orphan_release_metadata(struct inode *inode);
Miao Xied5c12072013-02-28 10:04:33 +00003444int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
3445 struct btrfs_block_rsv *rsv,
3446 int nitems,
Jeff Mahoneyee3441b2013-07-09 16:37:21 -04003447 u64 *qgroup_reserved, bool use_global_rsv);
Miao Xied5c12072013-02-28 10:04:33 +00003448void btrfs_subvolume_release_metadata(struct btrfs_root *root,
3449 struct btrfs_block_rsv *rsv,
3450 u64 qgroup_reserved);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003451int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
3452void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
3453int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
3454void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
Miao Xie66d8f3d2012-09-06 04:02:28 -06003455void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
3456struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
3457 unsigned short type);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003458void btrfs_free_block_rsv(struct btrfs_root *root,
3459 struct btrfs_block_rsv *rsv);
Josef Bacik4a92b1b2011-08-30 12:34:28 -04003460int btrfs_block_rsv_add(struct btrfs_root *root,
Miao Xie08e007d2012-10-16 11:33:38 +00003461 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
3462 enum btrfs_reserve_flush_enum flush);
Josef Bacik4a92b1b2011-08-30 12:34:28 -04003463int btrfs_block_rsv_check(struct btrfs_root *root,
Josef Bacik36ba0222011-10-18 12:15:48 -04003464 struct btrfs_block_rsv *block_rsv, int min_factor);
3465int btrfs_block_rsv_refill(struct btrfs_root *root,
Miao Xie08e007d2012-10-16 11:33:38 +00003466 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
3467 enum btrfs_reserve_flush_enum flush);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003468int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
3469 struct btrfs_block_rsv *dst_rsv,
3470 u64 num_bytes);
Josef Bacikd52be812013-05-29 14:54:47 -04003471int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
3472 struct btrfs_block_rsv *dest, u64 num_bytes,
3473 int min_factor);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003474void btrfs_block_rsv_release(struct btrfs_root *root,
3475 struct btrfs_block_rsv *block_rsv,
3476 u64 num_bytes);
3477int btrfs_set_block_group_ro(struct btrfs_root *root,
3478 struct btrfs_block_group_cache *cache);
Jeff Mahoney143bede2012-03-01 14:56:26 +01003479void btrfs_set_block_group_rw(struct btrfs_root *root,
3480 struct btrfs_block_group_cache *cache);
Josef Bacik0af3d002010-06-21 14:48:16 -04003481void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
Miao Xie6d07bce2011-01-05 10:07:31 +00003482u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
liuboacce9522011-01-06 19:30:25 +08003483int btrfs_error_unpin_extent_range(struct btrfs_root *root,
3484 u64 start, u64 end);
Filipe Manana1edb647b2014-12-08 14:01:12 +00003485int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
3486 u64 num_bytes, u64 *actual_bytes);
Chris Masonc87f08c2011-02-16 13:57:04 -05003487int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
3488 struct btrfs_root *root, u64 type);
Li Dongyangf7039b12011-03-24 10:24:28 +00003489int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
liuboacce9522011-01-06 19:30:25 +08003490
liuboc59021f2011-03-07 02:13:14 +00003491int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
Arne Jansenbed92ea2012-06-28 18:03:02 +02003492int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
3493 struct btrfs_fs_info *fs_info);
Liu Bo31e50222012-11-21 14:18:10 +00003494int __get_raid_index(u64 flags);
Filipe Manana9ea24bb2014-10-29 11:57:59 +00003495int btrfs_start_write_no_snapshoting(struct btrfs_root *root);
3496void btrfs_end_write_no_snapshoting(struct btrfs_root *root);
Chris Masondee26a92007-03-26 16:00:06 -04003497/* ctree.c */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003498int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
3499 int level, int *slot);
3500int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
Chris Mason0b86a832008-03-24 15:01:56 -04003501int btrfs_previous_item(struct btrfs_root *root,
3502 struct btrfs_path *path, u64 min_objectid,
3503 int type);
Wang Shilongade2e0b2014-01-12 21:38:33 +08003504int btrfs_previous_extent_item(struct btrfs_root *root,
3505 struct btrfs_path *path, u64 min_objectid);
Tsutomu Itohafe5fea2013-04-16 05:18:22 +00003506void btrfs_set_item_key_safe(struct btrfs_root *root, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01003507 struct btrfs_key *new_key);
Chris Mason925baed2008-06-25 16:01:30 -04003508struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
3509struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
Chris Masone7a84562008-06-25 16:01:31 -04003510int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
Chris Mason3f157a22008-06-25 16:01:31 -04003511 struct btrfs_key *key, int lowest_level,
Eric Sandeende78b512013-01-31 18:21:12 +00003512 u64 min_trans);
Chris Mason3f157a22008-06-25 16:01:31 -04003513int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
Eric Sandeende78b512013-01-31 18:21:12 +00003514 struct btrfs_path *path,
Chris Mason3f157a22008-06-25 16:01:31 -04003515 u64 min_trans);
Alexander Block70698302012-06-05 21:07:48 +02003516enum btrfs_compare_tree_result {
3517 BTRFS_COMPARE_TREE_NEW,
3518 BTRFS_COMPARE_TREE_DELETED,
3519 BTRFS_COMPARE_TREE_CHANGED,
Josef Bacikba5e8f22013-08-16 16:52:55 -04003520 BTRFS_COMPARE_TREE_SAME,
Alexander Block70698302012-06-05 21:07:48 +02003521};
3522typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root,
3523 struct btrfs_root *right_root,
3524 struct btrfs_path *left_path,
3525 struct btrfs_path *right_path,
3526 struct btrfs_key *key,
3527 enum btrfs_compare_tree_result result,
3528 void *ctx);
3529int btrfs_compare_trees(struct btrfs_root *left_root,
3530 struct btrfs_root *right_root,
3531 btrfs_changed_cb_t cb, void *ctx);
Chris Mason5f39d392007-10-15 16:14:19 -04003532int btrfs_cow_block(struct btrfs_trans_handle *trans,
3533 struct btrfs_root *root, struct extent_buffer *buf,
3534 struct extent_buffer *parent, int parent_slot,
Chris Mason9fa8cfe2009-03-13 10:24:59 -04003535 struct extent_buffer **cow_ret);
Chris Masonbe20aa92007-12-17 20:14:01 -05003536int btrfs_copy_root(struct btrfs_trans_handle *trans,
3537 struct btrfs_root *root,
3538 struct extent_buffer *buf,
3539 struct extent_buffer **cow_ret, u64 new_root_objectid);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003540int btrfs_block_can_be_shared(struct btrfs_root *root,
3541 struct extent_buffer *buf);
Tsutomu Itoh4b90c682013-04-16 05:18:49 +00003542void btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01003543 u32 data_size);
Tsutomu Itohafe5fea2013-04-16 05:18:22 +00003544void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01003545 u32 new_size, int from_end);
Chris Mason459931e2008-12-10 09:10:46 -05003546int btrfs_split_item(struct btrfs_trans_handle *trans,
3547 struct btrfs_root *root,
3548 struct btrfs_path *path,
3549 struct btrfs_key *new_key,
3550 unsigned long split_offset);
Yan, Zhengad48fd752009-11-12 09:33:58 +00003551int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
3552 struct btrfs_root *root,
3553 struct btrfs_path *path,
3554 struct btrfs_key *new_key);
Kelley Nielsene33d5c32013-11-04 19:33:33 -08003555int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
3556 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
Chris Masone089f052007-03-16 16:20:31 -04003557int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
3558 *root, struct btrfs_key *key, struct btrfs_path *p, int
3559 ins_len, int cow);
Jan Schmidt5d9e75c42012-05-16 18:25:47 +02003560int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
3561 struct btrfs_path *p, u64 time_seq);
Arne Jansen2f38b3e2011-09-13 11:18:10 +02003562int btrfs_search_slot_for_read(struct btrfs_root *root,
3563 struct btrfs_key *key, struct btrfs_path *p,
3564 int find_higher, int return_any);
Chris Mason6702ed42007-08-07 16:15:09 -04003565int btrfs_realloc_node(struct btrfs_trans_handle *trans,
Chris Mason5f39d392007-10-15 16:14:19 -04003566 struct btrfs_root *root, struct extent_buffer *parent,
Eric Sandeende78b512013-01-31 18:21:12 +00003567 int start_slot, u64 *last_ret,
Chris Masona6b6e752007-10-15 16:22:39 -04003568 struct btrfs_key *progress);
David Sterbab3b4aa72011-04-21 01:20:15 +02003569void btrfs_release_path(struct btrfs_path *p);
Chris Mason2c90e5d2007-04-02 10:50:19 -04003570struct btrfs_path *btrfs_alloc_path(void);
3571void btrfs_free_path(struct btrfs_path *p);
Chris Masonb4ce94d2009-02-04 09:25:08 -05003572void btrfs_set_path_blocking(struct btrfs_path *p);
Miao Xie16cdcec2011-04-22 18:12:22 +08003573void btrfs_clear_path_blocking(struct btrfs_path *p,
Chris Masonbd681512011-07-16 15:23:14 -04003574 struct extent_buffer *held, int held_rw);
Chris Masonb4ce94d2009-02-04 09:25:08 -05003575void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
3576
Chris Mason85e21ba2008-01-29 15:11:36 -05003577int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3578 struct btrfs_path *path, int slot, int nr);
Chris Mason85e21ba2008-01-29 15:11:36 -05003579static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
3580 struct btrfs_root *root,
3581 struct btrfs_path *path)
3582{
3583 return btrfs_del_items(trans, root, path, path->slots[0], 1);
3584}
3585
Tsutomu Itohafe5fea2013-04-16 05:18:22 +00003586void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01003587 struct btrfs_key *cpu_key, u32 *data_size,
3588 u32 total_data, u32 total_size, int nr);
Chris Masone089f052007-03-16 16:20:31 -04003589int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
3590 *root, struct btrfs_key *key, void *data, u32 data_size);
Chris Mason9c583092008-01-29 15:15:18 -05003591int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
3592 struct btrfs_root *root,
3593 struct btrfs_path *path,
3594 struct btrfs_key *cpu_key, u32 *data_size, int nr);
3595
3596static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
3597 struct btrfs_root *root,
3598 struct btrfs_path *path,
3599 struct btrfs_key *key,
3600 u32 data_size)
3601{
3602 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
3603}
3604
Chris Mason234b63a2007-03-13 10:46:10 -04003605int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
Josef Bacik16e75492013-10-22 12:18:51 -04003606int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
Jan Schmidt3d7806e2012-06-11 08:29:29 +02003607int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
3608 u64 time_seq);
Alexander Block1c8f52a2012-06-19 07:42:25 -06003609static inline int btrfs_next_old_item(struct btrfs_root *root,
3610 struct btrfs_path *p, u64 time_seq)
Jan Schmidtc7d22a32011-11-22 15:14:33 +01003611{
3612 ++p->slots[0];
3613 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
Alexander Block1c8f52a2012-06-19 07:42:25 -06003614 return btrfs_next_old_leaf(root, p, time_seq);
Jan Schmidtc7d22a32011-11-22 15:14:33 +01003615 return 0;
3616}
Alexander Block1c8f52a2012-06-19 07:42:25 -06003617static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
3618{
3619 return btrfs_next_old_item(root, p, 0);
3620}
Chris Mason5f39d392007-10-15 16:14:19 -04003621int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
Jeff Mahoney2c536792011-10-03 23:22:41 -04003622int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
3623 struct btrfs_block_rsv *block_rsv,
3624 int update_ref, int for_reloc);
Yan Zhengf82d02d2008-10-29 14:49:05 -04003625int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
3626 struct btrfs_root *root,
3627 struct extent_buffer *node,
3628 struct extent_buffer *parent);
David Sterba7841cb22011-05-31 18:07:27 +02003629static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
3630{
3631 /*
3632 * Get synced with close_ctree()
3633 */
3634 smp_mb();
3635 return fs_info->closing;
3636}
Miao Xiebabbf1702013-05-14 10:20:43 +00003637
3638/*
3639 * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
3640 * anything except sleeping. This function is used to check the status of
3641 * the fs.
3642 */
3643static inline int btrfs_need_cleaner_sleep(struct btrfs_root *root)
3644{
3645 return (root->fs_info->sb->s_flags & MS_RDONLY ||
3646 btrfs_fs_closing(root->fs_info));
3647}
3648
David Sterba6c417612011-04-13 15:41:04 +02003649static inline void free_fs_info(struct btrfs_fs_info *fs_info)
3650{
Ilya Dryomov837d5b62012-01-16 22:04:49 +02003651 kfree(fs_info->balance_ctl);
David Sterba6c417612011-04-13 15:41:04 +02003652 kfree(fs_info->delayed_root);
3653 kfree(fs_info->extent_root);
3654 kfree(fs_info->tree_root);
3655 kfree(fs_info->chunk_root);
3656 kfree(fs_info->dev_root);
3657 kfree(fs_info->csum_root);
Arne Jansenbcef60f2011-09-13 15:23:30 +02003658 kfree(fs_info->quota_root);
Filipe David Borba Mananad8f98032013-08-24 19:51:06 +01003659 kfree(fs_info->uuid_root);
David Sterba6c417612011-04-13 15:41:04 +02003660 kfree(fs_info->super_copy);
3661 kfree(fs_info->super_for_commit);
Qu Wenruof667aef2014-09-23 13:40:08 +08003662 security_free_mnt_opts(&fs_info->security_opts);
David Sterba6c417612011-04-13 15:41:04 +02003663 kfree(fs_info);
3664}
David Sterba7841cb22011-05-31 18:07:27 +02003665
Jan Schmidt097b8a72012-06-21 11:08:04 +02003666/* tree mod log functions from ctree.c */
3667u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
3668 struct seq_list *elem);
3669void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
3670 struct seq_list *elem);
Jan Schmidt5b6602e2012-10-23 11:28:27 +02003671int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
Jan Schmidt097b8a72012-06-21 11:08:04 +02003672
Chris Masondee26a92007-03-26 16:00:06 -04003673/* root-item.c */
Chris Masonea9e8b12008-11-17 21:14:24 -05003674int btrfs_find_root_ref(struct btrfs_root *tree_root,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003675 struct btrfs_path *path,
3676 u64 root_id, u64 ref_id);
Chris Mason0660b5a2008-11-17 20:37:39 -05003677int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
3678 struct btrfs_root *tree_root,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003679 u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
3680 const char *name, int name_len);
3681int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
3682 struct btrfs_root *tree_root,
3683 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
Chris Mason0660b5a2008-11-17 20:37:39 -05003684 const char *name, int name_len);
Chris Masone089f052007-03-16 16:20:31 -04003685int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3686 struct btrfs_key *key);
3687int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
3688 *root, struct btrfs_key *key, struct btrfs_root_item
3689 *item);
Jeff Mahoneyb45a9d82011-10-03 23:22:44 -04003690int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
3691 struct btrfs_root *root,
3692 struct btrfs_key *key,
3693 struct btrfs_root_item *item);
Miao Xiecb517ea2013-05-15 07:48:19 +00003694int btrfs_find_root(struct btrfs_root *root, struct btrfs_key *search_key,
3695 struct btrfs_path *path, struct btrfs_root_item *root_item,
3696 struct btrfs_key *root_key);
Yan, Zheng76dda932009-09-21 16:00:26 -04003697int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
Mark Fashehbf5f32e2011-07-14 21:23:06 +00003698void btrfs_set_root_node(struct btrfs_root_item *item,
3699 struct extent_buffer *node);
Li Zefan08fe4db2011-03-28 02:01:25 +00003700void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
Alexander Block8ea05e32012-07-25 17:35:53 +02003701void btrfs_update_root_times(struct btrfs_trans_handle *trans,
3702 struct btrfs_root *root);
Li Zefan08fe4db2011-03-28 02:01:25 +00003703
Stefan Behrens07b30a42013-08-15 17:11:17 +02003704/* uuid-tree.c */
3705int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans,
3706 struct btrfs_root *uuid_root, u8 *uuid, u8 type,
3707 u64 subid);
3708int btrfs_uuid_tree_rem(struct btrfs_trans_handle *trans,
3709 struct btrfs_root *uuid_root, u8 *uuid, u8 type,
3710 u64 subid);
Stefan Behrens70f80172013-08-15 17:11:23 +02003711int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
3712 int (*check_func)(struct btrfs_fs_info *, u8 *, u8,
3713 u64));
Stefan Behrens07b30a42013-08-15 17:11:17 +02003714
Chris Masondee26a92007-03-26 16:00:06 -04003715/* dir-item.c */
Chris Mason9c520572012-12-17 14:26:57 -05003716int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3717 const char *name, int name_len);
Chris Masond3977122009-01-05 21:25:51 -05003718int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
3719 struct btrfs_root *root, const char *name,
Miao Xie16cdcec2011-04-22 18:12:22 +08003720 int name_len, struct inode *dir,
Josef Bacikaec74772008-07-24 12:12:38 -04003721 struct btrfs_key *location, u8 type, u64 index);
Chris Mason7e381802007-04-19 15:36:27 -04003722struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
3723 struct btrfs_root *root,
3724 struct btrfs_path *path, u64 dir,
3725 const char *name, int name_len,
3726 int mod);
3727struct btrfs_dir_item *
3728btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
3729 struct btrfs_root *root,
3730 struct btrfs_path *path, u64 dir,
3731 u64 objectid, const char *name, int name_len,
3732 int mod);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003733struct btrfs_dir_item *
3734btrfs_search_dir_index_item(struct btrfs_root *root,
3735 struct btrfs_path *path, u64 dirid,
3736 const char *name, int name_len);
Chris Mason7e381802007-04-19 15:36:27 -04003737int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
3738 struct btrfs_root *root,
3739 struct btrfs_path *path,
3740 struct btrfs_dir_item *di);
Josef Bacik5103e942007-11-16 11:45:54 -05003741int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
Yan, Zhengf34f57a2009-11-12 09:35:27 +00003742 struct btrfs_root *root,
3743 struct btrfs_path *path, u64 objectid,
3744 const char *name, u16 name_len,
3745 const void *data, u16 data_len);
Josef Bacik5103e942007-11-16 11:45:54 -05003746struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3747 struct btrfs_root *root,
3748 struct btrfs_path *path, u64 dir,
3749 const char *name, u16 name_len,
3750 int mod);
Josef Bacik22a94d42011-03-16 16:47:17 -04003751int verify_dir_item(struct btrfs_root *root,
3752 struct extent_buffer *leaf,
3753 struct btrfs_dir_item *dir_item);
Filipe Manana5f5bc6b2014-11-09 08:38:39 +00003754struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
3755 struct btrfs_path *path,
3756 const char *name,
3757 int name_len);
Josef Bacik7b128762008-07-24 12:17:14 -04003758
3759/* orphan.c */
3760int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3761 struct btrfs_root *root, u64 offset);
3762int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3763 struct btrfs_root *root, u64 offset);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003764int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
Josef Bacik7b128762008-07-24 12:17:14 -04003765
Chris Masondee26a92007-03-26 16:00:06 -04003766/* inode-item.c */
Chris Mason39544012007-12-12 14:38:19 -05003767int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
3768 struct btrfs_root *root,
3769 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04003770 u64 inode_objectid, u64 ref_objectid, u64 index);
Chris Mason39544012007-12-12 14:38:19 -05003771int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
3772 struct btrfs_root *root,
3773 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04003774 u64 inode_objectid, u64 ref_objectid, u64 *index);
Chris Mason5f39d392007-10-15 16:14:19 -04003775int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
3776 struct btrfs_root *root,
3777 struct btrfs_path *path, u64 objectid);
Chris Mason293ffd52007-03-20 15:57:25 -04003778int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
Chris Masond6e4a422007-04-06 15:37:36 -04003779 *root, struct btrfs_path *path,
3780 struct btrfs_key *location, int mod);
Chris Masondee26a92007-03-26 16:00:06 -04003781
Mark Fashehf1863732012-08-08 11:32:27 -07003782struct btrfs_inode_extref *
3783btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
3784 struct btrfs_root *root,
3785 struct btrfs_path *path,
3786 const char *name, int name_len,
3787 u64 inode_objectid, u64 ref_objectid, int ins_len,
3788 int cow);
3789
3790int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
3791 u64 ref_objectid, const char *name,
3792 int name_len,
3793 struct btrfs_inode_extref **extref_ret);
3794
Chris Masondee26a92007-03-26 16:00:06 -04003795/* file-item.c */
Miao Xiefacc8a222013-07-25 19:22:34 +08003796struct btrfs_dio_private;
Chris Mason459931e2008-12-10 09:10:46 -05003797int btrfs_del_csums(struct btrfs_trans_handle *trans,
3798 struct btrfs_root *root, u64 bytenr, u64 len);
Chris Mason61b49442008-07-31 15:42:53 -04003799int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
Chris Masond20f7042008-12-08 16:58:54 -05003800 struct bio *bio, u32 *dst);
Josef Bacik4b46fce2010-05-23 11:00:55 -04003801int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
Miao Xie23ea8e52014-09-12 18:43:54 +08003802 struct bio *bio, u64 logical_offset);
Chris Masonb18c6682007-04-17 13:26:50 -04003803int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
Chris Masonc8b97812008-10-29 14:49:59 -04003804 struct btrfs_root *root,
3805 u64 objectid, u64 pos,
3806 u64 disk_offset, u64 disk_num_bytes,
3807 u64 num_bytes, u64 offset, u64 ram_bytes,
3808 u8 compression, u8 encryption, u16 other_encoding);
Chris Masondee26a92007-03-26 16:00:06 -04003809int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3810 struct btrfs_root *root,
3811 struct btrfs_path *path, u64 objectid,
Chris Masondb945352007-10-15 16:15:53 -04003812 u64 bytenr, int mod);
Chris Mason065631f2008-02-20 12:07:25 -05003813int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
Chris Masond20f7042008-12-08 16:58:54 -05003814 struct btrfs_root *root,
Chris Masone6dcd2d2008-07-17 12:53:50 -04003815 struct btrfs_ordered_sum *sums);
Chris Mason3edf7d32008-07-18 06:17:13 -04003816int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
Chris Masond20f7042008-12-08 16:58:54 -05003817 struct bio *bio, u64 file_start, int contig);
Arne Jansena2de7332011-03-08 14:14:00 +01003818int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3819 struct list_head *list, int search_commit);
Filipe Manana7ffbb592014-06-09 03:48:05 +01003820void btrfs_extent_item_to_extent_map(struct inode *inode,
3821 const struct btrfs_path *path,
3822 struct btrfs_file_extent_item *fi,
3823 const bool new_inline,
3824 struct extent_map *em);
3825
Chris Mason39279cc2007-06-12 06:35:45 -04003826/* inode.c */
Miao Xie8ccf6f192012-10-25 09:28:04 +00003827struct btrfs_delalloc_work {
3828 struct inode *inode;
3829 int wait;
3830 int delay_iput;
3831 struct completion completion;
3832 struct list_head list;
3833 struct btrfs_work work;
3834};
3835
3836struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
3837 int wait, int delay_iput);
3838void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
3839
Josef Bacikb2675152011-07-18 13:21:36 -04003840struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
3841 size_t pg_offset, u64 start, u64 len,
3842 int create);
Josef Bacik00361582013-08-14 14:02:47 -04003843noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
Josef Bacik7ee9e442013-06-21 16:37:03 -04003844 u64 *orig_start, u64 *orig_block_len,
3845 u64 *ram_bytes);
Chris Mason4881ee52008-07-24 09:51:08 -04003846
3847/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
Eric Sandeen5036f532008-08-07 11:19:42 -04003848#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
Chris Mason4881ee52008-07-24 09:51:08 -04003849#define ClearPageChecked ClearPageFsMisc
3850#define SetPageChecked SetPageFsMisc
3851#define PageChecked PageFsMisc
3852#endif
3853
Li Zefanb6973aa2011-07-20 03:46:35 +00003854/* This forces readahead on a given range of bytes in an inode */
3855static inline void btrfs_force_ra(struct address_space *mapping,
3856 struct file_ra_state *ra, struct file *file,
3857 pgoff_t offset, unsigned long req_size)
3858{
3859 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
3860}
3861
Chris Mason3de45862008-11-17 21:02:50 -05003862struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3863int btrfs_set_inode_index(struct inode *dir, u64 *index);
Chris Masone02119d2008-09-05 16:13:11 -04003864int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3865 struct btrfs_root *root,
3866 struct inode *dir, struct inode *inode,
3867 const char *name, int name_len);
3868int btrfs_add_link(struct btrfs_trans_handle *trans,
3869 struct inode *parent_inode, struct inode *inode,
3870 const char *name, int name_len, int add_backref, u64 index);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003871int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3872 struct btrfs_root *root,
3873 struct inode *dir, u64 objectid,
3874 const char *name, int name_len);
Josef Bacik2aaa6652012-08-29 14:27:18 -04003875int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
3876 int front);
Chris Masone02119d2008-09-05 16:13:11 -04003877int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3878 struct btrfs_root *root,
3879 struct inode *inode, u64 new_size,
3880 u32 min_type);
3881
Yan, Zheng24bbcf02009-11-12 09:36:34 +00003882int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
Miao Xie6c255e62014-03-06 13:55:01 +08003883int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput,
3884 int nr);
Josef Bacik2ac55d42010-02-03 19:33:23 +00003885int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3886 struct extent_state **cached_state);
Yan Zhengd2fb3432008-12-11 16:30:39 -05003887int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
Filipe David Borba Manana63541922014-01-07 11:47:46 +00003888 struct btrfs_root *new_root,
3889 struct btrfs_root *parent_root,
3890 u64 new_dirid);
David Woodhouse64a16702009-07-15 23:29:37 +01003891int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
3892 size_t size, struct bio *bio,
3893 unsigned long bio_flags);
Nick Pigginc2ec1752009-03-31 15:23:21 -07003894int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
Chris Mason9ebefb182007-06-15 13:50:00 -04003895int btrfs_readpage(struct file *file, struct page *page);
Al Virobd555972010-06-07 11:35:40 -04003896void btrfs_evict_inode(struct inode *inode);
Christoph Hellwiga9185b42010-03-05 09:21:37 +01003897int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
Chris Mason39279cc2007-06-12 06:35:45 -04003898struct inode *btrfs_alloc_inode(struct super_block *sb);
3899void btrfs_destroy_inode(struct inode *inode);
Al Viro45321ac2010-06-07 13:43:19 -04003900int btrfs_drop_inode(struct inode *inode);
Chris Mason39279cc2007-06-12 06:35:45 -04003901int btrfs_init_cachep(void);
3902void btrfs_destroy_cachep(void);
Sage Weil6bf13c02008-06-10 10:07:39 -04003903long btrfs_ioctl_trans_end(struct file *file);
Balaji Rao1a54ef82008-07-21 02:01:04 +05303904struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
Josef Bacik73f73412009-12-04 17:38:27 +00003905 struct btrfs_root *root, int *was_new);
Chris Masona52d9a82007-08-27 16:49:44 -04003906struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
David Sterba306e16c2011-04-19 14:29:38 +02003907 size_t pg_offset, u64 start, u64 end,
Chris Masona52d9a82007-08-27 16:49:44 -04003908 int create);
3909int btrfs_update_inode(struct btrfs_trans_handle *trans,
3910 struct btrfs_root *root,
3911 struct inode *inode);
Josef Bacikbe6aef62012-10-22 15:43:12 -04003912int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3913 struct btrfs_root *root, struct inode *inode);
Zheng Yan5b21f2e2008-09-26 10:05:38 -04003914int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
Josef Bacik66b4ffd2011-01-31 16:22:42 -05003915int btrfs_orphan_cleanup(struct btrfs_root *root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04003916void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3917 struct btrfs_root *root);
Josef Bacika41ad392011-01-31 15:30:16 -05003918int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
Jeff Mahoney143bede2012-03-01 14:56:26 +01003919void btrfs_invalidate_inodes(struct btrfs_root *root);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00003920void btrfs_add_delayed_iput(struct inode *inode);
3921void btrfs_run_delayed_iputs(struct btrfs_root *root);
Yan, Zhengefa56462010-05-16 10:49:59 -04003922int btrfs_prealloc_file_range(struct inode *inode, int mode,
3923 u64 start, u64 num_bytes, u64 min_size,
3924 loff_t actual_len, u64 *alloc_hint);
Josef Bacik0af3d002010-06-21 14:48:16 -04003925int btrfs_prealloc_file_range_trans(struct inode *inode,
3926 struct btrfs_trans_handle *trans, int mode,
3927 u64 start, u64 num_bytes, u64 min_size,
3928 loff_t actual_len, u64 *alloc_hint);
Filipe Mananab38ef712014-11-13 17:01:45 +00003929int btrfs_inode_check_errors(struct inode *inode);
Alexey Dobriyan82d339d2009-10-09 09:54:36 -04003930extern const struct dentry_operations btrfs_dentry_operations;
Christoph Hellwigf46b5a62008-06-11 21:53:53 -04003931
3932/* ioctl.c */
3933long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Christoph Hellwig6cbff002009-04-17 10:37:41 +02003934void btrfs_update_iflags(struct inode *inode);
3935void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02003936int btrfs_is_empty_uuid(u8 *uuid);
Chris Mason4cb53002011-05-24 15:35:30 -04003937int btrfs_defrag_file(struct inode *inode, struct file *file,
3938 struct btrfs_ioctl_defrag_range_args *range,
3939 u64 newer_than, unsigned long max_pages);
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003940void btrfs_get_block_group_info(struct list_head *groups_list,
3941 struct btrfs_ioctl_space_info *space);
Stefan Behrens35a36212013-08-14 18:12:25 +02003942void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
3943 struct btrfs_ioctl_balance_args *bargs);
3944
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003945
Chris Mason39279cc2007-06-12 06:35:45 -04003946/* file.c */
Miao Xie9247f312012-11-26 09:24:43 +00003947int btrfs_auto_defrag_init(void);
3948void btrfs_auto_defrag_exit(void);
Chris Mason4cb53002011-05-24 15:35:30 -04003949int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3950 struct inode *inode);
3951int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
Miao Xie26176e72012-11-26 09:26:20 +00003952void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
Josef Bacik02c24a82011-07-16 20:44:56 -04003953int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
Josef Bacik7014cdb2012-08-30 20:06:49 -04003954void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
3955 int skip_pinned);
Alexey Dobriyan828c0952009-10-01 15:43:56 -07003956extern const struct file_operations btrfs_file_operations;
Josef Bacik5dc562c2012-08-17 13:14:17 -04003957int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3958 struct btrfs_root *root, struct inode *inode,
3959 struct btrfs_path *path, u64 start, u64 end,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00003960 u64 *drop_end, int drop_cache,
3961 int replace_extent,
3962 u32 extent_item_size,
3963 int *key_inserted);
Josef Bacik5dc562c2012-08-17 13:14:17 -04003964int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3965 struct btrfs_root *root, struct inode *inode, u64 start,
Josef Bacik26714852012-08-29 12:24:27 -04003966 u64 end, int drop_cache);
Yan Zhengd899e052008-10-30 14:25:28 -04003967int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
Yan Zhengd899e052008-10-30 14:25:28 -04003968 struct inode *inode, u64 start, u64 end);
Sage Weil6bf13c02008-06-10 10:07:39 -04003969int btrfs_release_file(struct inode *inode, struct file *file);
Josef Bacikbe1a12a2011-04-06 13:05:22 -04003970int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
3971 struct page **pages, size_t num_pages,
3972 loff_t pos, size_t write_bytes,
3973 struct extent_state **cached);
Filipe Manana728404d2014-10-10 09:43:11 +01003974int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
Sage Weil6bf13c02008-06-10 10:07:39 -04003975
Chris Mason6702ed42007-08-07 16:15:09 -04003976/* tree-defrag.c */
3977int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
Eric Sandeende78b512013-01-31 18:21:12 +00003978 struct btrfs_root *root);
Josef Bacik58176a92007-08-29 15:47:34 -04003979
3980/* sysfs.c */
3981int btrfs_init_sysfs(void);
3982void btrfs_exit_sysfs(void);
Jeff Mahoney5ac1d202013-11-01 13:06:58 -04003983int btrfs_sysfs_add_one(struct btrfs_fs_info *fs_info);
3984void btrfs_sysfs_remove_one(struct btrfs_fs_info *fs_info);
Josef Bacik58176a92007-08-29 15:47:34 -04003985
Josef Bacik5103e942007-11-16 11:45:54 -05003986/* xattr.c */
3987ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
Josef Bacik6099afe2008-07-24 12:16:03 -04003988
Chris Masonedbd8d42007-12-21 16:27:24 -05003989/* super.c */
Christoph Hellwigedf24ab2008-06-10 10:40:29 -04003990int btrfs_parse_options(struct btrfs_root *root, char *options);
Sage Weil6bf13c02008-06-10 10:07:39 -04003991int btrfs_sync_fs(struct super_block *sb, int wait);
Joe Perches533574c2012-07-30 14:40:13 -07003992
3993#ifdef CONFIG_PRINTK
3994__printf(2, 3)
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003995void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
Joe Perches533574c2012-07-30 14:40:13 -07003996#else
3997static inline __printf(2, 3)
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003998void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
Joe Perches533574c2012-07-30 14:40:13 -07003999{
4000}
4001#endif
4002
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00004003#define btrfs_emerg(fs_info, fmt, args...) \
4004 btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
4005#define btrfs_alert(fs_info, fmt, args...) \
4006 btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
4007#define btrfs_crit(fs_info, fmt, args...) \
4008 btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
4009#define btrfs_err(fs_info, fmt, args...) \
4010 btrfs_printk(fs_info, KERN_ERR fmt, ##args)
4011#define btrfs_warn(fs_info, fmt, args...) \
4012 btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
4013#define btrfs_notice(fs_info, fmt, args...) \
4014 btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
4015#define btrfs_info(fs_info, fmt, args...) \
4016 btrfs_printk(fs_info, KERN_INFO fmt, ##args)
Frank Holton27a0dd62013-11-12 19:22:53 -05004017
4018#ifdef DEBUG
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00004019#define btrfs_debug(fs_info, fmt, args...) \
4020 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
Frank Holton27a0dd62013-11-12 19:22:53 -05004021#else
4022#define btrfs_debug(fs_info, fmt, args...) \
4023 no_printk(KERN_DEBUG fmt, ##args)
4024#endif
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00004025
Josef Bacik2e17c7c2013-08-26 16:53:15 -04004026#ifdef CONFIG_BTRFS_ASSERT
4027
4028static inline void assfail(char *expr, char *file, int line)
4029{
Frank Holtonefe120a2013-12-20 11:37:06 -05004030 pr_err("BTRFS: assertion failed: %s, file: %s, line: %d",
Josef Bacik2e17c7c2013-08-26 16:53:15 -04004031 expr, file, line);
4032 BUG();
4033}
4034
4035#define ASSERT(expr) \
4036 (likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
4037#else
4038#define ASSERT(expr) ((void)0)
4039#endif
4040
4041#define btrfs_assert()
Joe Perches533574c2012-07-30 14:40:13 -07004042__printf(5, 6)
liuboacce9522011-01-06 19:30:25 +08004043void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
Jeff Mahoney4da35112012-03-01 14:57:30 +01004044 unsigned int line, int errno, const char *fmt, ...);
liuboacce9522011-01-06 19:30:25 +08004045
Joe Perches533574c2012-07-30 14:40:13 -07004046
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004047void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
4048 struct btrfs_root *root, const char *function,
4049 unsigned int line, int errno);
4050
Mitch Harder2b0ce2c2012-07-24 11:58:43 -06004051#define btrfs_set_fs_incompat(__fs_info, opt) \
4052 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
4053
4054static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
4055 u64 flag)
4056{
4057 struct btrfs_super_block *disk_super;
4058 u64 features;
4059
4060 disk_super = fs_info->super_copy;
4061 features = btrfs_super_incompat_flags(disk_super);
4062 if (!(features & flag)) {
Miao Xieceda0862013-04-11 10:30:16 +00004063 spin_lock(&fs_info->super_lock);
4064 features = btrfs_super_incompat_flags(disk_super);
4065 if (!(features & flag)) {
4066 features |= flag;
4067 btrfs_set_super_incompat_flags(disk_super, features);
Frank Holtonefe120a2013-12-20 11:37:06 -05004068 btrfs_info(fs_info, "setting %llu feature flag",
Miao Xieceda0862013-04-11 10:30:16 +00004069 flag);
4070 }
4071 spin_unlock(&fs_info->super_lock);
Mitch Harder2b0ce2c2012-07-24 11:58:43 -06004072 }
4073}
4074
Josef Bacik3173a182013-03-07 14:22:04 -05004075#define btrfs_fs_incompat(fs_info, opt) \
4076 __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
4077
4078static inline int __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
4079{
4080 struct btrfs_super_block *disk_super;
4081 disk_super = fs_info->super_copy;
4082 return !!(btrfs_super_incompat_flags(disk_super) & flag);
4083}
4084
David Sterba005d6422012-09-18 07:52:32 -06004085/*
4086 * Call btrfs_abort_transaction as early as possible when an error condition is
4087 * detected, that way the exact line number is reported.
4088 */
4089
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004090#define btrfs_abort_transaction(trans, root, errno) \
4091do { \
4092 __btrfs_abort_transaction(trans, root, __func__, \
4093 __LINE__, errno); \
4094} while (0)
liuboacce9522011-01-06 19:30:25 +08004095
4096#define btrfs_std_error(fs_info, errno) \
4097do { \
4098 if ((errno)) \
Jeff Mahoney4da35112012-03-01 14:57:30 +01004099 __btrfs_std_error((fs_info), __func__, \
4100 __LINE__, (errno), NULL); \
4101} while (0)
4102
4103#define btrfs_error(fs_info, errno, fmt, args...) \
4104do { \
4105 __btrfs_std_error((fs_info), __func__, __LINE__, \
4106 (errno), fmt, ##args); \
liuboacce9522011-01-06 19:30:25 +08004107} while (0)
Josef Bacik33268ea2008-07-24 12:16:36 -04004108
Joe Perches533574c2012-07-30 14:40:13 -07004109__printf(5, 6)
Jeff Mahoney8c342932011-10-03 23:22:31 -04004110void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
4111 unsigned int line, int errno, const char *fmt, ...);
4112
Eric Sandeenaa43a172013-01-31 00:54:55 +00004113/*
4114 * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
4115 * will panic(). Otherwise we BUG() here.
4116 */
Jeff Mahoney8c342932011-10-03 23:22:31 -04004117#define btrfs_panic(fs_info, errno, fmt, args...) \
4118do { \
Eric Sandeenaa43a172013-01-31 00:54:55 +00004119 __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \
4120 BUG(); \
Chris Masoneb60cea2007-02-02 09:18:22 -05004121} while (0)
4122
4123/* acl.c */
4124#ifdef CONFIG_BTRFS_FS_POSIX_ACL
Christoph Hellwig4e34e712011-07-23 17:37:31 +02004125struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
Christoph Hellwig996a7102013-12-20 05:16:43 -08004126int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
Chris Masoneb60cea2007-02-02 09:18:22 -05004127int btrfs_init_acl(struct btrfs_trans_handle *trans,
4128 struct inode *inode, struct inode *dir);
Li Zefan9b89d952011-07-14 03:17:39 +00004129#else
Linus Torvaldsed8f3732011-08-02 21:14:05 -10004130#define btrfs_get_acl NULL
Christoph Hellwig996a7102013-12-20 05:16:43 -08004131#define btrfs_set_acl NULL
Li Zefan9b89d952011-07-14 03:17:39 +00004132static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
4133 struct inode *inode, struct inode *dir)
4134{
4135 return 0;
4136}
Li Zefan9b89d952011-07-14 03:17:39 +00004137#endif
Chris Masoneb60cea2007-02-02 09:18:22 -05004138
4139/* relocation.c */
4140int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
4141int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
4142 struct btrfs_root *root);
4143int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
4144 struct btrfs_root *root);
4145int btrfs_recover_relocation(struct btrfs_root *root);
4146int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
Josef Bacik83d4cfd2013-08-30 15:09:51 -04004147int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
4148 struct btrfs_root *root, struct extent_buffer *buf,
4149 struct extent_buffer *cow);
Chris Masoneb60cea2007-02-02 09:18:22 -05004150void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
4151 struct btrfs_pending_snapshot *pending,
4152 u64 *bytes_to_reserve);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004153int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
Chris Masoneb60cea2007-02-02 09:18:22 -05004154 struct btrfs_pending_snapshot *pending);
Arne Jansena2de7332011-03-08 14:14:00 +01004155
4156/* scrub.c */
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01004157int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
4158 u64 end, struct btrfs_scrub_progress *progress,
Stefan Behrens63a212a2012-11-05 18:29:28 +01004159 int readonly, int is_dev_replace);
Jeff Mahoney143bede2012-03-01 14:56:26 +01004160void btrfs_scrub_pause(struct btrfs_root *root);
Jeff Mahoney143bede2012-03-01 14:56:26 +01004161void btrfs_scrub_continue(struct btrfs_root *root);
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01004162int btrfs_scrub_cancel(struct btrfs_fs_info *info);
4163int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
4164 struct btrfs_device *dev);
Arne Jansena2de7332011-03-08 14:14:00 +01004165int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
4166 struct btrfs_scrub_progress *progress);
4167
Miao Xiec404e0d2014-01-30 16:46:55 +08004168/* dev-replace.c */
4169void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
4170void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
Miao Xie42452152014-11-25 16:39:28 +08004171void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);
4172
4173static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
4174{
4175 btrfs_bio_counter_sub(fs_info, 1);
4176}
Miao Xiec404e0d2014-01-30 16:46:55 +08004177
Arne Jansen7414a032011-05-23 14:33:49 +02004178/* reada.c */
4179struct reada_control {
4180 struct btrfs_root *root; /* tree to prefetch */
4181 struct btrfs_key key_start;
4182 struct btrfs_key key_end; /* exclusive */
4183 atomic_t elems;
4184 struct kref refcnt;
4185 wait_queue_head_t wait;
4186};
4187struct reada_control *btrfs_reada_add(struct btrfs_root *root,
4188 struct btrfs_key *start, struct btrfs_key *end);
4189int btrfs_reada_wait(void *handle);
4190void btrfs_reada_detach(void *handle);
4191int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,
4192 u64 start, int err);
4193
Jan Schmidt95a06072012-05-29 17:06:54 +02004194static inline int is_fstree(u64 rootid)
4195{
4196 if (rootid == BTRFS_FS_TREE_OBJECTID ||
4197 (s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID)
4198 return 1;
4199 return 0;
4200}
David Sterba210549e2013-02-09 23:38:06 +00004201
4202static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
4203{
4204 return signal_pending(current);
4205}
4206
Josef Bacikaaedb552013-10-11 14:44:09 -04004207/* Sanity test specific functions */
4208#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
4209void btrfs_test_destroy_inode(struct inode *inode);
4210#endif
David Sterba210549e2013-02-09 23:38:06 +00004211
David Sterbafccb84c2014-09-29 23:53:21 +02004212static inline int btrfs_test_is_dummy_root(struct btrfs_root *root)
4213{
4214#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
4215 if (unlikely(test_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state)))
4216 return 1;
4217#endif
4218 return 0;
4219}
4220
Chris Masoneb60cea2007-02-02 09:18:22 -05004221#endif