blob: fc1864acb3682802de78d87cd2589387e8331205 [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>
Jeff Mahoneydb671162016-04-01 16:14:29 -040036#include <linux/btrfs_tree.h>
Miao Xie21c7e752014-05-13 17:29:04 -070037#include <linux/workqueue.h>
Qu Wenruof667aef2014-09-23 13:40:08 +080038#include <linux/security.h>
Byongho Leeee221842015-12-15 01:42:10 +090039#include <linux/sizes.h>
Jeff Mahoney897a41b2016-08-31 23:55:33 -040040#include <linux/dynamic_debug.h>
Chris Masond1310b22008-01-24 16:13:08 -050041#include "extent_io.h"
Chris Mason5f39d392007-10-15 16:14:19 -040042#include "extent_map.h"
Chris Mason8b712842008-06-11 16:50:36 -040043#include "async-thread.h"
Chris Masone20d96d2007-03-22 12:13:20 -040044
Chris Masone089f052007-03-16 16:20:31 -040045struct btrfs_trans_handle;
Chris Mason79154b12007-03-22 15:59:16 -040046struct btrfs_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -040047struct btrfs_pending_snapshot;
Chris Mason35b7e472007-05-02 15:53:43 -040048extern struct kmem_cache *btrfs_trans_handle_cachep;
49extern struct kmem_cache *btrfs_transaction_cachep;
50extern struct kmem_cache *btrfs_bit_radix_cachep;
Chris Mason2c90e5d2007-04-02 10:50:19 -040051extern struct kmem_cache *btrfs_path_cachep;
Josef Bacikdc89e982011-01-28 17:05:48 -050052extern struct kmem_cache *btrfs_free_space_cachep;
Chris Masone6dcd2d2008-07-17 12:53:50 -040053struct btrfs_ordered_sum;
Chris Masone089f052007-03-16 16:20:31 -040054
Josef Bacik294e30f2013-10-09 12:00:56 -040055#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
56#define STATIC noinline
57#else
58#define STATIC static noinline
59#endif
60
Zach Browncdb4c572013-02-20 00:55:13 +000061#define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
Chris Masoneb60cea2007-02-02 09:18:22 -050062
Stefan Behrens72d7aef2012-11-06 14:57:46 +010063#define BTRFS_MAX_MIRRORS 3
Stefan Behrens94598ba2012-03-27 14:21:26 -040064
Chris Mason4008c042009-02-12 14:09:45 -050065#define BTRFS_MAX_LEVEL 8
Chris Mason0b86a832008-03-24 15:01:56 -040066
Yan Zheng5d4f98a2009-06-10 10:45:14 -040067#define BTRFS_COMPAT_EXTENT_TREE_V0
68
Chris Masonfec577f2007-02-26 10:40:21 -050069/*
Chris Mason727011e2010-08-06 13:21:20 -040070 * the max metadata block size. This limit is somewhat artificial,
71 * but the memmove costs go through the roof for larger blocks.
72 */
73#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
74
75/*
Chris Masone20d96d2007-03-22 12:13:20 -040076 * we can actually store much bigger names, but lets not confuse the rest
77 * of linux
78 */
79#define BTRFS_NAME_LEN 255
80
Mark Fashehf1863732012-08-08 11:32:27 -070081/*
82 * Theoretical limit is larger, but we keep this down to a sane
83 * value. That should limit greatly the possibility of collisions on
84 * inode ref items.
85 */
86#define BTRFS_LINK_MAX 65535U
87
David Sterba4d4ab6d2015-11-19 11:42:31 +010088static const int btrfs_csum_sizes[] = { 4 };
Josef Bacik607d4322008-12-02 07:17:45 -050089
Chris Mason509659c2007-05-10 12:36:17 -040090/* four bytes for CRC32 */
Chris Mason39544012007-12-12 14:38:19 -050091#define BTRFS_EMPTY_DIR_SIZE 0
Chris Masonf254e522007-03-29 15:15:27 -040092
Stefan Behrens3d136a12012-02-03 11:20:04 +010093/* ioprio of readahead is set to idle */
94#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
95
Byongho Leeee221842015-12-15 01:42:10 +090096#define BTRFS_DIRTY_METADATA_THRESH SZ_32M
Miao Xiee2d84522013-01-29 10:09:20 +000097
Byongho Leeee221842015-12-15 01:42:10 +090098#define BTRFS_MAX_EXTENT_SIZE SZ_128M
Josef Bacikdcab6a32015-02-11 15:08:59 -050099
Chris Mason0b86a832008-03-24 15:01:56 -0400100struct btrfs_mapping_tree {
101 struct extent_map_tree map_tree;
102};
103
Chris Mason0b86a832008-03-24 15:01:56 -0400104static inline unsigned long btrfs_chunk_item_size(int num_stripes)
105{
106 BUG_ON(num_stripes == 0);
107 return sizeof(struct btrfs_chunk) +
108 sizeof(struct btrfs_stripe) * (num_stripes - 1);
109}
110
liuboacce9522011-01-06 19:30:25 +0800111/*
112 * File system states
113 */
Miao Xie87533c42013-01-29 10:14:48 +0000114#define BTRFS_FS_STATE_ERROR 0
Miao Xiedc81cdc2013-02-20 23:32:52 -0700115#define BTRFS_FS_STATE_REMOUNTING 1
David Sterba08748812013-03-12 14:46:08 +0000116#define BTRFS_FS_STATE_TRANS_ABORTED 2
Miao Xiec404e0d2014-01-30 16:46:55 +0800117#define BTRFS_FS_STATE_DEV_REPLACING 3
Jeff Mahoney7c0260e2016-06-20 14:14:09 -0400118#define BTRFS_FS_STATE_DUMMY_FS_INFO 4
liuboacce9522011-01-06 19:30:25 +0800119
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400120#define BTRFS_BACKREF_REV_MAX 256
121#define BTRFS_BACKREF_REV_SHIFT 56
122#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
123 BTRFS_BACKREF_REV_SHIFT)
124
125#define BTRFS_OLD_BACKREF_REV 0
126#define BTRFS_MIXED_BACKREF_REV 1
Chris Mason63b10fc2008-04-01 11:21:32 -0400127
Chris Masonfec577f2007-02-26 10:40:21 -0500128/*
129 * every tree block (leaf or node) starts with this header.
130 */
Chris Masonbb492bb2007-03-12 12:29:44 -0400131struct btrfs_header {
Chris Masone17cade2008-04-15 15:41:47 -0400132 /* these first four must match the super block */
Chris Masonf254e522007-03-29 15:15:27 -0400133 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason5f39d392007-10-15 16:14:19 -0400134 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400135 __le64 bytenr; /* which block this node is supposed to live in */
Chris Mason63b10fc2008-04-01 11:21:32 -0400136 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400137
138 /* allowed to be different from the super from here on down */
139 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason7f5c1512007-03-23 15:56:19 -0400140 __le64 generation;
Chris Mason4d775672007-04-20 20:23:12 -0400141 __le64 owner;
Chris Mason5f39d392007-10-15 16:14:19 -0400142 __le32 nritems;
Chris Mason9a6f11e2007-03-27 09:06:38 -0400143 u8 level;
Chris Masoneb60cea2007-02-02 09:18:22 -0500144} __attribute__ ((__packed__));
145
Chris Mason0b86a832008-03-24 15:01:56 -0400146/*
147 * this is a very generous portion of the super block, giving us
148 * room to translate 14 chunks with 3 stripes each.
149 */
150#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
151
Chris Masonfec577f2007-02-26 10:40:21 -0500152/*
Chris Masonaf31f5e2011-11-03 15:17:42 -0400153 * just in case we somehow lose the roots and are not able to mount,
154 * we store an array of the roots from previous transactions
155 * in the super.
156 */
157#define BTRFS_NUM_BACKUP_ROOTS 4
158struct btrfs_root_backup {
159 __le64 tree_root;
160 __le64 tree_root_gen;
161
162 __le64 chunk_root;
163 __le64 chunk_root_gen;
164
165 __le64 extent_root;
166 __le64 extent_root_gen;
167
168 __le64 fs_root;
169 __le64 fs_root_gen;
170
171 __le64 dev_root;
172 __le64 dev_root_gen;
173
174 __le64 csum_root;
175 __le64 csum_root_gen;
176
177 __le64 total_bytes;
178 __le64 bytes_used;
179 __le64 num_devices;
180 /* future */
Masanari Iidad1423242012-10-31 15:16:32 +0000181 __le64 unused_64[4];
Chris Masonaf31f5e2011-11-03 15:17:42 -0400182
183 u8 tree_root_level;
184 u8 chunk_root_level;
185 u8 extent_root_level;
186 u8 fs_root_level;
187 u8 dev_root_level;
188 u8 csum_root_level;
189 /* future and to align */
190 u8 unused_8[10];
191} __attribute__ ((__packed__));
192
193/*
Chris Masonfec577f2007-02-26 10:40:21 -0500194 * the super block basically lists the main trees of the FS
195 * it currently lacks any block count etc etc
196 */
Chris Mason234b63a2007-03-13 10:46:10 -0400197struct btrfs_super_block {
Chris Masonf254e522007-03-29 15:15:27 -0400198 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason63b10fc2008-04-01 11:21:32 -0400199 /* the first 4 fields must match struct btrfs_header */
Yan Zheng2b820322008-11-17 21:11:30 -0500200 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400201 __le64 bytenr; /* this block number */
Chris Mason63b10fc2008-04-01 11:21:32 -0400202 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400203
204 /* allowed to be different from the btrfs_header from here own down */
Chris Mason3768f362007-03-13 16:47:54 -0400205 __le64 magic;
Chris Mason3768f362007-03-13 16:47:54 -0400206 __le64 generation;
207 __le64 root;
Chris Mason0b86a832008-03-24 15:01:56 -0400208 __le64 chunk_root;
Chris Masone02119d2008-09-05 16:13:11 -0400209 __le64 log_root;
Chris Masonc3027eb2008-12-08 16:40:21 -0500210
211 /* this will help find the new super based on the log root */
212 __le64 log_root_transid;
Chris Masondb945352007-10-15 16:15:53 -0400213 __le64 total_bytes;
214 __le64 bytes_used;
Chris Mason2e635a22007-03-21 11:12:56 -0400215 __le64 root_dir_objectid;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400216 __le64 num_devices;
Chris Mason5f39d392007-10-15 16:14:19 -0400217 __le32 sectorsize;
218 __le32 nodesize;
David Sterba707e8a02014-06-04 19:22:26 +0200219 __le32 __unused_leafsize;
Chris Mason87ee04e2007-11-30 11:30:34 -0500220 __le32 stripesize;
Chris Mason0b86a832008-03-24 15:01:56 -0400221 __le32 sys_chunk_array_size;
Yan Zheng84234f32008-10-29 14:49:05 -0400222 __le64 chunk_root_generation;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500223 __le64 compat_flags;
224 __le64 compat_ro_flags;
225 __le64 incompat_flags;
Josef Bacik607d4322008-12-02 07:17:45 -0500226 __le16 csum_type;
Chris Masondb945352007-10-15 16:15:53 -0400227 u8 root_level;
Chris Mason0b86a832008-03-24 15:01:56 -0400228 u8 chunk_root_level;
Chris Masone02119d2008-09-05 16:13:11 -0400229 u8 log_root_level;
Chris Mason0d81ba52008-03-24 15:02:07 -0400230 struct btrfs_dev_item dev_item;
Chris Masonc3027eb2008-12-08 16:40:21 -0500231
Chris Mason7ae9c092008-04-18 10:29:49 -0400232 char label[BTRFS_LABEL_SIZE];
Chris Masonc3027eb2008-12-08 16:40:21 -0500233
Josef Bacik0af3d002010-06-21 14:48:16 -0400234 __le64 cache_generation;
Stefan Behrens26432792013-08-15 17:11:22 +0200235 __le64 uuid_tree_generation;
Josef Bacik0af3d002010-06-21 14:48:16 -0400236
Chris Masonc3027eb2008-12-08 16:40:21 -0500237 /* future expansion */
Stefan Behrens26432792013-08-15 17:11:22 +0200238 __le64 reserved[30];
Chris Mason0b86a832008-03-24 15:01:56 -0400239 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
Chris Masonaf31f5e2011-11-03 15:17:42 -0400240 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
Chris Masoncfaa7292007-02-21 17:04:57 -0500241} __attribute__ ((__packed__));
242
Chris Masonfec577f2007-02-26 10:40:21 -0500243/*
Josef Bacikf2b636e2008-12-02 06:36:08 -0500244 * Compat flags that we support. If any incompat flags are set other than the
245 * ones specified below then we will fail to mount
246 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400247#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500248#define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL
249#define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL
Omar Sandoval70f6d822015-09-29 20:50:38 -0700250
251#define BTRFS_FEATURE_COMPAT_RO_SUPP \
Omar Sandoval6675df32016-09-22 17:24:22 -0700252 (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \
253 BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID)
Omar Sandoval70f6d822015-09-29 20:50:38 -0700254
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500255#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL
256#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL
257
Josef Bacik0af3d002010-06-21 14:48:16 -0400258#define BTRFS_FEATURE_INCOMPAT_SUPP \
259 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
Josef Bacik67377732010-09-16 16:19:09 -0400260 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
Li Zefana6fa6fa2010-10-25 15:12:26 +0800261 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
Chris Mason727011e2010-08-06 13:21:20 -0400262 BTRFS_FEATURE_INCOMPAT_BIG_METADATA | \
Mark Fashehf1863732012-08-08 11:32:27 -0700263 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO | \
David Woodhouse53b381b2013-01-29 18:40:14 -0500264 BTRFS_FEATURE_INCOMPAT_RAID56 | \
Josef Bacik3173a182013-03-07 14:22:04 -0500265 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF | \
Josef Bacik16e75492013-10-22 12:18:51 -0400266 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | \
267 BTRFS_FEATURE_INCOMPAT_NO_HOLES)
Josef Bacikf2b636e2008-12-02 06:36:08 -0500268
Jeff Mahoney2eaa0552013-11-15 15:33:55 -0500269#define BTRFS_FEATURE_INCOMPAT_SAFE_SET \
270 (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
271#define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR 0ULL
Josef Bacikf2b636e2008-12-02 06:36:08 -0500272
273/*
Chris Mason62e27492007-03-15 12:56:47 -0400274 * A leaf is full of items. offset and size tell us where to find
Chris Masonfec577f2007-02-26 10:40:21 -0500275 * the item in the leaf (relative to the start of the data area)
276 */
Chris Mason0783fcf2007-03-12 20:12:07 -0400277struct btrfs_item {
Chris Masone2fa7222007-03-12 16:22:34 -0400278 struct btrfs_disk_key key;
Chris Mason123abc82007-03-14 14:14:43 -0400279 __le32 offset;
Chris Mason5f39d392007-10-15 16:14:19 -0400280 __le32 size;
Chris Masoneb60cea2007-02-02 09:18:22 -0500281} __attribute__ ((__packed__));
282
Chris Masonfec577f2007-02-26 10:40:21 -0500283/*
284 * leaves have an item area and a data area:
285 * [item0, item1....itemN] [free space] [dataN...data1, data0]
286 *
287 * The data is separate from the items to get the keys closer together
288 * during searches.
289 */
Chris Mason234b63a2007-03-13 10:46:10 -0400290struct btrfs_leaf {
Chris Masonbb492bb2007-03-12 12:29:44 -0400291 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400292 struct btrfs_item items[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500293} __attribute__ ((__packed__));
294
Chris Masonfec577f2007-02-26 10:40:21 -0500295/*
296 * all non-leaf blocks are nodes, they hold only keys and pointers to
297 * other blocks
298 */
Chris Mason123abc82007-03-14 14:14:43 -0400299struct btrfs_key_ptr {
300 struct btrfs_disk_key key;
301 __le64 blockptr;
Chris Mason74493f72007-12-11 09:25:06 -0500302 __le64 generation;
Chris Mason123abc82007-03-14 14:14:43 -0400303} __attribute__ ((__packed__));
304
Chris Mason234b63a2007-03-13 10:46:10 -0400305struct btrfs_node {
Chris Masonbb492bb2007-03-12 12:29:44 -0400306 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400307 struct btrfs_key_ptr ptrs[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500308} __attribute__ ((__packed__));
309
Chris Masonfec577f2007-02-26 10:40:21 -0500310/*
Chris Mason234b63a2007-03-13 10:46:10 -0400311 * btrfs_paths remember the path taken from the root down to the leaf.
312 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
Chris Masonfec577f2007-02-26 10:40:21 -0500313 * to any other levels that are present.
314 *
315 * The slots array records the index of the item or block pointer
316 * used while walking the tree.
317 */
David Sterbae4058b52015-11-27 16:31:35 +0100318enum { READA_NONE = 0, READA_BACK, READA_FORWARD };
Chris Mason234b63a2007-03-13 10:46:10 -0400319struct btrfs_path {
Chris Mason5f39d392007-10-15 16:14:19 -0400320 struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
Chris Mason234b63a2007-03-13 10:46:10 -0400321 int slots[BTRFS_MAX_LEVEL];
Chris Mason925baed2008-06-25 16:01:30 -0400322 /* if there is real range locking, this locks field will change */
David Sterba4fb72bf2015-11-27 16:31:45 +0100323 u8 locks[BTRFS_MAX_LEVEL];
David Sterbadccabfa2015-11-27 16:31:38 +0100324 u8 reada;
Chris Mason925baed2008-06-25 16:01:30 -0400325 /* keep some upper locks as we walk down */
David Sterba7853f152015-11-27 16:31:42 +0100326 u8 lowest_level;
Chris Mason459931e2008-12-10 09:10:46 -0500327
328 /*
329 * set by btrfs_split_item, tells search_slot to keep all locks
330 * and to force calls to keep space in the nodes
331 */
Chris Masonb9473432009-03-13 11:00:37 -0400332 unsigned int search_for_split:1;
333 unsigned int keep_locks:1;
334 unsigned int skip_locking:1;
335 unsigned int leave_spinning:1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400336 unsigned int search_commit_root:1;
Josef Bacik3f8a18c2014-03-28 17:16:01 -0400337 unsigned int need_commit_sem:1;
Filipe Manana5f5bc6b2014-11-09 08:38:39 +0000338 unsigned int skip_release_on_error:1;
Chris Masoneb60cea2007-02-02 09:18:22 -0500339};
Jeff Mahoneyda170662016-06-15 09:22:56 -0400340#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400341 sizeof(struct btrfs_item))
Stefan Behrense922e082012-11-05 17:26:40 +0100342struct btrfs_dev_replace {
343 u64 replace_state; /* see #define above */
344 u64 time_started; /* seconds since 1-Jan-1970 */
345 u64 time_stopped; /* seconds since 1-Jan-1970 */
346 atomic64_t num_write_errors;
347 atomic64_t num_uncorrectable_read_errors;
348
349 u64 cursor_left;
350 u64 committed_cursor_left;
351 u64 cursor_left_last_write_of_item;
352 u64 cursor_right;
353
354 u64 cont_reading_from_srcdev_mode; /* see #define above */
355
356 int is_valid;
357 int item_needs_writeback;
358 struct btrfs_device *srcdev;
359 struct btrfs_device *tgtdev;
360
361 pid_t lock_owner;
362 atomic_t nesting_level;
363 struct mutex lock_finishing_cancel_unmount;
Liu Bo73beece2015-07-17 16:49:19 +0800364 rwlock_t lock;
365 atomic_t read_locks;
366 atomic_t blocking_readers;
367 wait_queue_head_t read_lock_wq;
Stefan Behrense922e082012-11-05 17:26:40 +0100368
369 struct btrfs_scrub_progress scrub_progress;
370};
371
Jeff Mahoneyc1895442014-05-27 12:59:57 -0400372/* For raid type sysfs entries */
373struct raid_kobject {
374 int raid_type;
375 struct kobject kobj;
376};
377
Chris Mason6324fbf2008-03-24 15:01:59 -0400378struct btrfs_space_info {
Miao Xie26b47ff2014-01-15 20:00:54 +0800379 spinlock_t lock;
Josef Bacik6a632092009-02-20 11:00:09 -0500380
Josef Bacik89a55892010-10-14 14:52:27 -0400381 u64 total_bytes; /* total bytes in the space,
382 this doesn't take mirrors into account */
Yan, Zhengb742bb822010-05-16 10:46:24 -0400383 u64 bytes_used; /* total bytes used,
Lucas De Marchie9c54992011-04-26 23:28:26 -0700384 this doesn't take mirrors into account */
Josef Bacik6a632092009-02-20 11:00:09 -0500385 u64 bytes_pinned; /* total bytes pinned, will be freed when the
386 transaction finishes */
387 u64 bytes_reserved; /* total bytes the allocator has reserved for
388 current allocations */
Josef Bacik6a632092009-02-20 11:00:09 -0500389 u64 bytes_may_use; /* number of bytes that may be used for
Josef Bacik9ed74f22009-09-11 16:12:44 -0400390 delalloc/allocations */
Miao Xie26b47ff2014-01-15 20:00:54 +0800391 u64 bytes_readonly; /* total bytes that are read only */
392
Josef Bacik4f4db212015-09-29 11:40:47 -0400393 u64 max_extent_size; /* This will hold the maximum extent size of
394 the space info if we had an ENOSPC in the
395 allocator. */
396
Miao Xie26b47ff2014-01-15 20:00:54 +0800397 unsigned int full:1; /* indicates that we cannot allocate any more
398 chunks for this space */
399 unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
400
401 unsigned int flush:1; /* set if we are trying to make space */
402
403 unsigned int force_alloc; /* set if we need to force a chunk
404 alloc for this space */
405
Yan, Zhengb742bb822010-05-16 10:46:24 -0400406 u64 disk_used; /* total bytes used on disk */
Josef Bacik89a55892010-10-14 14:52:27 -0400407 u64 disk_total; /* total bytes on disk, takes mirrors into
408 account */
Josef Bacik6a632092009-02-20 11:00:09 -0500409
Miao Xie26b47ff2014-01-15 20:00:54 +0800410 u64 flags;
411
Chris Mason36e39c42011-03-12 07:08:42 -0500412 /*
Josef Bacikb150a4f2013-06-19 15:00:04 -0400413 * bytes_pinned is kept in line with what is actually pinned, as in
414 * we've called update_block_group and dropped the bytes_used counter
415 * and increased the bytes_pinned counter. However this means that
416 * bytes_pinned does not reflect the bytes that will be pinned once the
Adam Buchbinderbb7ab3b2016-03-04 11:23:12 -0800417 * delayed refs are flushed, so this counter is inc'ed every time we
418 * call btrfs_free_extent so it is a realtime count of what will be
Nicholas D Steeves01327612016-05-19 21:18:45 -0400419 * freed once the transaction is committed. It will be zeroed every
Adam Buchbinderbb7ab3b2016-03-04 11:23:12 -0800420 * time the transaction commits.
Josef Bacikb150a4f2013-06-19 15:00:04 -0400421 */
422 struct percpu_counter total_bytes_pinned;
423
Chris Mason6324fbf2008-03-24 15:01:59 -0400424 struct list_head list;
Filipe Manana75c68e92015-01-16 13:24:40 +0000425 /* Protected by the spinlock 'lock'. */
Josef Bacik633c0aa2014-10-31 09:49:34 -0400426 struct list_head ro_bgs;
Josef Bacik957780e2016-05-17 13:30:55 -0400427 struct list_head priority_tickets;
428 struct list_head tickets;
Wang Xiaoguang939659d2016-11-07 15:59:16 +0800429 /*
430 * tickets_id just indicates the next ticket will be handled, so note
431 * it's not stored per ticket.
432 */
Wang Xiaoguangce129652016-09-02 10:58:46 +0800433 u64 tickets_id;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400434
Miao Xie26b47ff2014-01-15 20:00:54 +0800435 struct rw_semaphore groups_sem;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400436 /* for block groups in our same type */
Yan, Zhengb742bb822010-05-16 10:46:24 -0400437 struct list_head block_groups[BTRFS_NR_RAID_TYPES];
Josef Bacikfdb5eff2011-06-07 16:07:44 -0400438 wait_queue_head_t wait;
Jeff Mahoney6ab0a202013-11-01 13:07:04 -0400439
440 struct kobject kobj;
Jeff Mahoneyc1895442014-05-27 12:59:57 -0400441 struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES];
Josef Bacik0f9dd462008-09-23 13:14:11 -0400442};
443
Miao Xie66d8f3d2012-09-06 04:02:28 -0600444#define BTRFS_BLOCK_RSV_GLOBAL 1
445#define BTRFS_BLOCK_RSV_DELALLOC 2
446#define BTRFS_BLOCK_RSV_TRANS 3
447#define BTRFS_BLOCK_RSV_CHUNK 4
448#define BTRFS_BLOCK_RSV_DELOPS 5
449#define BTRFS_BLOCK_RSV_EMPTY 6
450#define BTRFS_BLOCK_RSV_TEMP 7
451
Yan, Zhengf0486c62010-05-16 10:46:25 -0400452struct btrfs_block_rsv {
453 u64 size;
454 u64 reserved;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400455 struct btrfs_space_info *space_info;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400456 spinlock_t lock;
Miao Xie66d8f3d2012-09-06 04:02:28 -0600457 unsigned short full;
458 unsigned short type;
459 unsigned short failfast;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400460};
461
Chris Masonfa9c0d792009-04-03 09:47:43 -0400462/*
463 * free clusters are used to claim free space in relatively large chunks,
464 * allowing us to do less seeky writes. They are used for all metadata
465 * allocations and data allocations in ssd mode.
466 */
467struct btrfs_free_cluster {
468 spinlock_t lock;
469 spinlock_t refill_lock;
470 struct rb_root root;
471
472 /* largest extent in this cluster */
473 u64 max_size;
474
475 /* first extent starting offset */
476 u64 window_start;
477
Josef Bacikc759c4e2015-10-02 15:25:10 -0400478 /* We did a full search and couldn't create a cluster */
479 bool fragmented;
480
Chris Masonfa9c0d792009-04-03 09:47:43 -0400481 struct btrfs_block_group_cache *block_group;
482 /*
483 * when a cluster is allocated from a block group, we put the
484 * cluster onto a list in the block group so that it can
485 * be freed before the block group is freed.
486 */
487 struct list_head block_group_list;
Chris Mason6324fbf2008-03-24 15:01:59 -0400488};
489
Josef Bacik817d52f2009-07-13 21:29:25 -0400490enum btrfs_caching_type {
491 BTRFS_CACHE_NO = 0,
492 BTRFS_CACHE_STARTED = 1,
Josef Bacik291c7d22011-11-14 13:52:14 -0500493 BTRFS_CACHE_FAST = 2,
494 BTRFS_CACHE_FINISHED = 3,
Josef Bacik36cce922013-08-05 11:15:21 -0400495 BTRFS_CACHE_ERROR = 4,
Josef Bacik817d52f2009-07-13 21:29:25 -0400496};
497
Josef Bacik0af3d002010-06-21 14:48:16 -0400498enum btrfs_disk_cache_state {
499 BTRFS_DC_WRITTEN = 0,
500 BTRFS_DC_ERROR = 1,
501 BTRFS_DC_CLEAR = 2,
502 BTRFS_DC_SETUP = 3,
Josef Bacik0af3d002010-06-21 14:48:16 -0400503};
504
Yan Zheng11833d62009-09-11 16:11:19 -0400505struct btrfs_caching_control {
506 struct list_head list;
507 struct mutex mutex;
508 wait_queue_head_t wait;
Josef Bacikbab39bf2011-06-30 14:42:28 -0400509 struct btrfs_work work;
Yan Zheng11833d62009-09-11 16:11:19 -0400510 struct btrfs_block_group_cache *block_group;
511 u64 progress;
512 atomic_t count;
513};
514
Omar Sandoval73fa48b2015-09-29 20:50:33 -0700515/* Once caching_thread() finds this much free space, it will wake up waiters. */
516#define CACHING_CTL_WAKE_UP (1024 * 1024 * 2)
517
Chris Mason4c6d1d82015-04-06 13:17:20 -0700518struct btrfs_io_ctl {
519 void *cur, *orig;
520 struct page *page;
521 struct page **pages;
Jeff Mahoneyf15376d2016-06-22 18:56:18 -0400522 struct btrfs_fs_info *fs_info;
Chris Masonc9dc4c62015-04-04 17:14:42 -0700523 struct inode *inode;
Chris Mason4c6d1d82015-04-06 13:17:20 -0700524 unsigned long size;
525 int index;
526 int num_pages;
Chris Masonc9dc4c62015-04-04 17:14:42 -0700527 int entries;
528 int bitmaps;
Chris Mason4c6d1d82015-04-06 13:17:20 -0700529 unsigned check_crcs:1;
530};
531
Chris Mason9078a3e2007-04-26 16:46:15 -0400532struct btrfs_block_group_cache {
533 struct btrfs_key key;
534 struct btrfs_block_group_item item;
Josef Bacik817d52f2009-07-13 21:29:25 -0400535 struct btrfs_fs_info *fs_info;
Josef Bacik0af3d002010-06-21 14:48:16 -0400536 struct inode *inode;
Chris Masonc286ac42008-07-22 23:06:41 -0400537 spinlock_t lock;
Yan324ae4d2007-11-16 14:57:08 -0500538 u64 pinned;
Zheng Yane8569812008-09-26 10:05:48 -0400539 u64 reserved;
Miao Xiee570fd22014-06-19 10:42:50 +0800540 u64 delalloc_bytes;
Josef Bacik1b2da372009-09-11 16:11:20 -0400541 u64 bytes_super;
Chris Mason0b86a832008-03-24 15:01:56 -0400542 u64 flags;
Josef Bacik5b0e95b2011-10-06 08:58:24 -0400543 u64 cache_generation;
Omar Sandovala5ed9182015-09-29 20:50:35 -0700544 u32 sectorsize;
545
546 /*
547 * If the free space extent count exceeds this number, convert the block
548 * group to bitmaps.
549 */
550 u32 bitmap_high_thresh;
551
552 /*
553 * If the free space extent count drops below this number, convert the
554 * block group back to extents.
555 */
556 u32 bitmap_low_thresh;
David Woodhouse53b381b2013-01-29 18:40:14 -0500557
Miao Xiee570fd22014-06-19 10:42:50 +0800558 /*
559 * It is just used for the delayed data space allocation because
560 * only the data space allocation and the relative metadata update
561 * can be done cross the transaction.
562 */
563 struct rw_semaphore data_rwsem;
564
David Woodhouse53b381b2013-01-29 18:40:14 -0500565 /* for raid56, this is a full stripe, without parity */
566 unsigned long full_stripe_len;
567
Zhaolei868f4012015-08-05 16:43:27 +0800568 unsigned int ro;
Mariusz Kozlowski0410c942010-11-20 12:03:07 +0000569 unsigned int iref:1;
Filipe Manana4f69cb92014-11-26 15:28:51 +0000570 unsigned int has_caching_ctl:1;
Filipe Manana04216822014-11-27 21:14:15 +0000571 unsigned int removed:1;
Josef Bacik0af3d002010-06-21 14:48:16 -0400572
573 int disk_cache_state;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400574
Josef Bacik817d52f2009-07-13 21:29:25 -0400575 /* cache tracking stuff */
Josef Bacik817d52f2009-07-13 21:29:25 -0400576 int cached;
Yan Zheng11833d62009-09-11 16:11:19 -0400577 struct btrfs_caching_control *caching_ctl;
578 u64 last_byte_to_unpin;
Josef Bacik817d52f2009-07-13 21:29:25 -0400579
Josef Bacik0f9dd462008-09-23 13:14:11 -0400580 struct btrfs_space_info *space_info;
581
582 /* free space cache stuff */
Li Zefan34d52cb2011-03-29 13:46:06 +0800583 struct btrfs_free_space_ctl *free_space_ctl;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400584
585 /* block group cache stuff */
586 struct rb_node cache_node;
587
588 /* for block groups in the same raid type */
589 struct list_head list;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500590
591 /* usage count */
592 atomic_t count;
Chris Masonfa9c0d792009-04-03 09:47:43 -0400593
594 /* List of struct btrfs_free_clusters for this block group.
595 * Today it will only have one thing on it, but that may change
596 */
597 struct list_head cluster_list;
Josef Bacikea658ba2012-09-11 16:57:25 -0400598
Josef Bacik47ab2a62014-09-18 11:20:02 -0400599 /* For delayed block group creation or deletion of empty block groups */
600 struct list_head bg_list;
Josef Bacik633c0aa2014-10-31 09:49:34 -0400601
602 /* For read-only block groups */
603 struct list_head ro_list;
Filipe Manana04216822014-11-27 21:14:15 +0000604
605 atomic_t trimming;
Josef Bacikce93ec52014-11-17 15:45:48 -0500606
607 /* For dirty block groups */
608 struct list_head dirty_list;
Chris Masonc9dc4c62015-04-04 17:14:42 -0700609 struct list_head io_list;
610
611 struct btrfs_io_ctl io_ctl;
Omar Sandovala5ed9182015-09-29 20:50:35 -0700612
Filipe Manana9cfa3e32016-04-26 15:39:32 +0100613 /*
614 * Incremented when doing extent allocations and holding a read lock
615 * on the space_info's groups_sem semaphore.
616 * Decremented when an ordered extent that represents an IO against this
617 * block group's range is created (after it's added to its inode's
618 * root's list of ordered extents) or immediately after the allocation
619 * if it's a metadata extent or fallocate extent (for these cases we
620 * don't create ordered extents).
621 */
622 atomic_t reservations;
623
Filipe Mananaf78c4362016-05-09 13:15:41 +0100624 /*
625 * Incremented while holding the spinlock *lock* by a task checking if
626 * it can perform a nocow write (incremented if the value for the *ro*
627 * field is 0). Decremented by such tasks once they create an ordered
628 * extent or before that if some error happens before reaching that step.
629 * This is to prevent races between block group relocation and nocow
630 * writes through direct IO.
631 */
632 atomic_t nocow_writers;
633
Omar Sandovala5ed9182015-09-29 20:50:35 -0700634 /* Lock for free space tree operations. */
635 struct mutex free_space_lock;
636
637 /*
638 * Does the block group need to be added to the free space tree?
639 * Protected by free_space_lock.
640 */
641 int needs_free_space;
Chris Mason9078a3e2007-04-26 16:46:15 -0400642};
Chris Mason0b86a832008-03-24 15:01:56 -0400643
Jan Schmidt097b8a72012-06-21 11:08:04 +0200644/* delayed seq elem */
645struct seq_list {
646 struct list_head list;
647 u64 seq;
648};
649
David Sterba3284da72015-02-25 15:47:32 +0100650#define SEQ_LIST_INIT(name) { .list = LIST_HEAD_INIT((name).list), .seq = 0 }
651
Josef Bacik5d803662013-02-07 16:06:02 -0500652enum btrfs_orphan_cleanup_state {
653 ORPHAN_CLEANUP_STARTED = 1,
654 ORPHAN_CLEANUP_DONE = 2,
655};
656
David Woodhouse53b381b2013-01-29 18:40:14 -0500657/* used by the raid56 code to lock stripes for read/modify/write */
658struct btrfs_stripe_hash {
659 struct list_head hash_list;
660 wait_queue_head_t wait;
661 spinlock_t lock;
662};
663
664/* used by the raid56 code to lock stripes for read/modify/write */
665struct btrfs_stripe_hash_table {
Chris Mason4ae10b32013-01-31 14:42:09 -0500666 struct list_head stripe_cache;
667 spinlock_t cache_lock;
668 int cache_size;
669 struct btrfs_stripe_hash table[];
David Woodhouse53b381b2013-01-29 18:40:14 -0500670};
671
672#define BTRFS_STRIPE_HASH_TABLE_BITS 11
673
Miao Xie21c7e752014-05-13 17:29:04 -0700674void btrfs_init_async_reclaim_work(struct work_struct *work);
675
Jan Schmidt097b8a72012-06-21 11:08:04 +0200676/* fs_info */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400677struct reloc_control;
Chris Mason0b86a832008-03-24 15:01:56 -0400678struct btrfs_device;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400679struct btrfs_fs_devices;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200680struct btrfs_balance_control;
Miao Xie16cdcec2011-04-22 18:12:22 +0800681struct btrfs_delayed_root;
Josef Bacikafcdd122016-09-02 15:40:02 -0400682
683#define BTRFS_FS_BARRIER 1
684#define BTRFS_FS_CLOSING_START 2
685#define BTRFS_FS_CLOSING_DONE 3
686#define BTRFS_FS_LOG_RECOVERING 4
687#define BTRFS_FS_OPEN 5
688#define BTRFS_FS_QUOTA_ENABLED 6
689#define BTRFS_FS_QUOTA_ENABLING 7
690#define BTRFS_FS_QUOTA_DISABLING 8
691#define BTRFS_FS_UPDATE_UUID_TREE_GEN 9
692#define BTRFS_FS_CREATING_FREE_SPACE_TREE 10
693#define BTRFS_FS_BTREE_ERR 11
694#define BTRFS_FS_LOG1_ERR 12
695#define BTRFS_FS_LOG2_ERR 13
696
Chris Mason9f5fae22007-03-20 14:38:32 -0400697struct btrfs_fs_info {
Chris Mason5f39d392007-10-15 16:14:19 -0400698 u8 fsid[BTRFS_FSID_SIZE];
Chris Masone17cade2008-04-15 15:41:47 -0400699 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Josef Bacikafcdd122016-09-02 15:40:02 -0400700 unsigned long flags;
Chris Mason9f5fae22007-03-20 14:38:32 -0400701 struct btrfs_root *extent_root;
702 struct btrfs_root *tree_root;
Chris Mason0b86a832008-03-24 15:01:56 -0400703 struct btrfs_root *chunk_root;
704 struct btrfs_root *dev_root;
Chris Mason3de45862008-11-17 21:02:50 -0500705 struct btrfs_root *fs_root;
Chris Masond20f7042008-12-08 16:58:54 -0500706 struct btrfs_root *csum_root;
Arne Jansen416ac512011-09-13 12:56:09 +0200707 struct btrfs_root *quota_root;
Stefan Behrensf7a81ea2013-08-15 17:11:19 +0200708 struct btrfs_root *uuid_root;
Omar Sandovala5ed9182015-09-29 20:50:35 -0700709 struct btrfs_root *free_space_root;
Chris Masone02119d2008-09-05 16:13:11 -0400710
711 /* the log root tree is a directory of all the other log roots */
712 struct btrfs_root *log_root_tree;
Yan, Zheng4df27c4d2009-09-21 15:56:00 -0400713
714 spinlock_t fs_roots_radix_lock;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400715 struct radix_tree_root fs_roots_radix;
Chris Mason1a5bc162007-10-15 16:15:26 -0400716
Josef Bacik0f9dd462008-09-23 13:14:11 -0400717 /* block group cache stuff */
718 spinlock_t block_group_cache_lock;
Liu Boa1897fd2012-12-27 09:01:23 +0000719 u64 first_logical_byte;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400720 struct rb_root block_group_cache_tree;
721
Josef Bacik2bf64752011-09-26 17:12:22 -0400722 /* keep track of unallocated space */
723 spinlock_t free_chunk_lock;
724 u64 free_chunk_space;
725
Yan Zheng11833d62009-09-11 16:11:19 -0400726 struct extent_io_tree freed_extents[2];
727 struct extent_io_tree *pinned_extents;
Chris Mason1a5bc162007-10-15 16:15:26 -0400728
Chris Mason0b86a832008-03-24 15:01:56 -0400729 /* logical->physical extent mapping */
730 struct btrfs_mapping_tree mapping_tree;
731
Miao Xie16cdcec2011-04-22 18:12:22 +0800732 /*
733 * block reservation for extent, checksum, root tree and
734 * delayed dir index item
735 */
Yan, Zhengf0486c62010-05-16 10:46:25 -0400736 struct btrfs_block_rsv global_block_rsv;
737 /* block reservation for delay allocation */
738 struct btrfs_block_rsv delalloc_block_rsv;
739 /* block reservation for metadata operations */
740 struct btrfs_block_rsv trans_block_rsv;
741 /* block reservation for chunk tree */
742 struct btrfs_block_rsv chunk_block_rsv;
Josef Bacik6d668dd2011-11-03 22:54:25 -0400743 /* block reservation for delayed operations */
744 struct btrfs_block_rsv delayed_block_rsv;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400745
746 struct btrfs_block_rsv empty_block_rsv;
747
Chris Mason293ffd52007-03-20 15:57:25 -0400748 u64 generation;
Josef Bacik15ee9bc2007-08-10 16:22:09 -0400749 u64 last_trans_committed;
Josef Bacik0a2b2a82014-01-23 10:54:11 -0500750 u64 avg_delayed_ref_runtime;
Chris Mason12fcfd22009-03-24 10:24:20 -0400751
752 /*
753 * this is updated to the current trans every time a full commit
754 * is required instead of the faster short fsync log commits
755 */
756 u64 last_trans_log_full_commit;
Stefan Behrens25cd9992012-03-30 13:58:32 +0200757 unsigned long mount_opt;
David Sterba572d9ab2014-02-05 15:26:17 +0100758 /*
759 * Track requests for actions that need to be done during transaction
760 * commit (like for some mount options).
761 */
762 unsigned long pending_changes;
Li Zefan261507a02010-12-17 14:21:50 +0800763 unsigned long compress_type:4;
David Sterba8b87dc12013-08-01 18:14:52 +0200764 int commit_interval;
Miao Xie8c6a3ee2013-01-29 10:05:05 +0000765 /*
766 * It is a suggestive number, the read side is safe even it gets a
767 * wrong number because we will write out the data into a regular
768 * extent. The write side(mount/remount) is under ->s_umount lock,
769 * so it is also safe.
770 */
Chris Mason6f568d32008-01-29 16:03:38 -0500771 u64 max_inline;
Miao Xiec018dae2013-01-29 10:07:33 +0000772 /*
773 * Protected by ->chunk_mutex and sb->s_umount.
774 *
775 * The reason that we use two lock to protect it is because only
776 * remount and mount operations can change it and these two operations
777 * are under sb->s_umount, but the read side (chunk allocation) can not
778 * acquire sb->s_umount or the deadlock would happen. So we use two
779 * locks to protect it. On the write side, we must acquire two locks,
780 * and on the read side, we just need acquire one of them.
781 */
Chris Mason8f662a72008-01-02 10:01:11 -0500782 u64 alloc_start;
Chris Mason79154b12007-03-22 15:59:16 -0400783 struct btrfs_transaction *running_transaction;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400784 wait_queue_head_t transaction_throttle;
Chris Masonf9295742008-07-17 12:54:14 -0400785 wait_queue_head_t transaction_wait;
Sage Weilbb9c12c2010-10-29 15:37:34 -0400786 wait_queue_head_t transaction_blocked_wait;
Chris Mason771ed682008-11-06 22:02:51 -0500787 wait_queue_head_t async_submit_wait;
Chris Masone02119d2008-09-05 16:13:11 -0400788
Miao Xieceda0862013-04-11 10:30:16 +0000789 /*
790 * Used to protect the incompat_flags, compat_flags, compat_ro_flags
791 * when they are updated.
792 *
793 * Because we do not clear the flags for ever, so we needn't use
794 * the lock on the read side.
795 *
796 * We also needn't use the lock when we mount the fs, because
797 * there is no other task which will update the flag.
798 */
799 spinlock_t super_lock;
David Sterba6c417612011-04-13 15:41:04 +0200800 struct btrfs_super_block *super_copy;
801 struct btrfs_super_block *super_for_commit;
Chris Masone20d96d2007-03-22 12:13:20 -0400802 struct super_block *sb;
Chris Masond98237b2007-03-28 13:57:48 -0400803 struct inode *btree_inode;
Chris Mason04160082008-03-26 10:28:07 -0400804 struct backing_dev_info bdi;
Chris Masone02119d2008-09-05 16:13:11 -0400805 struct mutex tree_log_mutex;
Chris Masona74a4b92008-06-25 16:01:31 -0400806 struct mutex transaction_kthread_mutex;
807 struct mutex cleaner_mutex;
Chris Mason925baed2008-06-25 16:01:30 -0400808 struct mutex chunk_mutex;
Chris Mason7d9eb122008-07-08 14:19:17 -0400809 struct mutex volume_mutex;
David Woodhouse53b381b2013-01-29 18:40:14 -0500810
Chris Mason1bbc6212015-04-06 12:46:08 -0700811 /*
812 * this is taken to make sure we don't set block groups ro after
813 * the free space cache has been allocated on them
814 */
815 struct mutex ro_block_group_mutex;
816
David Woodhouse53b381b2013-01-29 18:40:14 -0500817 /* this is used during read/modify/write to make sure
818 * no two ios are trying to mod the same stripe at the same
819 * time
820 */
821 struct btrfs_stripe_hash_table *stripe_hash_table;
822
Chris Mason5a3f23d2009-03-31 13:27:11 -0400823 /*
824 * this protects the ordered operations list only while we are
825 * processing all of the entries on it. This way we make
826 * sure the commit code doesn't find the list temporarily empty
827 * because another function happens to be doing non-waiting preflush
828 * before jumping into the main commit.
829 */
830 struct mutex ordered_operations_mutex;
Josef Bacik9ffba8c2013-08-14 11:33:56 -0400831
Josef Bacik9e351cc2014-03-13 15:42:13 -0400832 struct rw_semaphore commit_root_sem;
Chris Mason5a3f23d2009-03-31 13:27:11 -0400833
Yan, Zhengc71bf092009-11-12 09:34:40 +0000834 struct rw_semaphore cleanup_work_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -0400835
Yan, Zhengc71bf092009-11-12 09:34:40 +0000836 struct rw_semaphore subvol_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -0400837 struct srcu_struct subvol_srcu;
838
Josef Bacika4abeea2011-04-11 17:25:13 -0400839 spinlock_t trans_lock;
Chris Mason75857172011-06-13 20:00:16 -0400840 /*
841 * the reloc mutex goes with the trans lock, it is taken
842 * during commit to protect us from the relocation code
843 */
844 struct mutex reloc_mutex;
845
Chris Mason8fd17792007-04-19 21:01:03 -0400846 struct list_head trans_list;
Chris Masonfacda1e2007-06-08 18:11:48 -0400847 struct list_head dead_roots;
Yan Zheng11833d62009-09-11 16:11:19 -0400848 struct list_head caching_block_groups;
Chris Masone02119d2008-09-05 16:13:11 -0400849
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000850 spinlock_t delayed_iput_lock;
851 struct list_head delayed_iputs;
Filipe Mananac2d6cb12016-01-15 11:05:12 +0000852 struct mutex cleaner_delayed_iput_mutex;
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000853
Jan Schmidtf29021b2012-05-16 17:55:38 +0200854 /* this protects tree_mod_seq_list */
855 spinlock_t tree_mod_seq_lock;
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +0000856 atomic64_t tree_mod_seq;
Jan Schmidtf29021b2012-05-16 17:55:38 +0200857 struct list_head tree_mod_seq_list;
858
859 /* this protects tree_mod_log */
860 rwlock_t tree_mod_log_lock;
861 struct rb_root tree_mod_log;
862
Chris Masoncb03c742008-05-15 16:15:45 -0400863 atomic_t nr_async_submits;
Chris Mason8c8bee12008-09-29 11:19:10 -0400864 atomic_t async_submit_draining;
Chris Mason0986fe9e2008-08-15 15:34:15 -0400865 atomic_t nr_async_bios;
Chris Mason771ed682008-11-06 22:02:51 -0500866 atomic_t async_delalloc_pages;
Josef Bacika4abeea2011-04-11 17:25:13 -0400867 atomic_t open_ioctl_trans;
Chris Masonce9adaa2008-04-09 16:28:12 -0400868
Chris Mason8b712842008-06-11 16:50:36 -0400869 /*
Miao Xie199c2a92013-05-15 07:48:23 +0000870 * this is used to protect the following list -- ordered_roots.
Chris Mason3eaa2882008-07-24 11:57:52 -0400871 */
Miao Xie199c2a92013-05-15 07:48:23 +0000872 spinlock_t ordered_root_lock;
Chris Mason5a3f23d2009-03-31 13:27:11 -0400873
874 /*
Miao Xie199c2a92013-05-15 07:48:23 +0000875 * all fs/file tree roots in which there are data=ordered extents
876 * pending writeback are added into this list.
877 *
Chris Mason5a3f23d2009-03-31 13:27:11 -0400878 * these can span multiple transactions and basically include
879 * every dirty data page that isn't from nodatacow
880 */
Miao Xie199c2a92013-05-15 07:48:23 +0000881 struct list_head ordered_roots;
Chris Mason5a3f23d2009-03-31 13:27:11 -0400882
Miao Xie573bfb72014-03-06 13:55:03 +0800883 struct mutex delalloc_root_mutex;
Miao Xieeb73c1b2013-05-15 07:48:22 +0000884 spinlock_t delalloc_root_lock;
885 /* all fs/file tree roots that have delalloc inodes. */
886 struct list_head delalloc_roots;
Chris Mason3eaa2882008-07-24 11:57:52 -0400887
888 /*
Chris Mason8b712842008-06-11 16:50:36 -0400889 * there is a pool of worker threads for checksumming during writes
890 * and a pool for checksumming after reads. This is because readers
891 * can run with FS locks held, and the writers may be waiting for
892 * those locks. We don't want ordering in the pending list to cause
893 * deadlocks, and so the two are serviced separately.
Chris Mason1cc127b2008-06-12 14:46:17 -0400894 *
895 * A third pool does submit_bio to avoid deadlocking with the other
896 * two
Chris Mason8b712842008-06-11 16:50:36 -0400897 */
Qu Wenruod458b052014-02-28 10:46:19 +0800898 struct btrfs_workqueue *workers;
899 struct btrfs_workqueue *delalloc_workers;
900 struct btrfs_workqueue *flush_workers;
901 struct btrfs_workqueue *endio_workers;
902 struct btrfs_workqueue *endio_meta_workers;
903 struct btrfs_workqueue *endio_raid56_workers;
Miao Xie8b110e32014-09-12 18:44:03 +0800904 struct btrfs_workqueue *endio_repair_workers;
Qu Wenruod458b052014-02-28 10:46:19 +0800905 struct btrfs_workqueue *rmw_workers;
906 struct btrfs_workqueue *endio_meta_write_workers;
907 struct btrfs_workqueue *endio_write_workers;
908 struct btrfs_workqueue *endio_freespace_worker;
909 struct btrfs_workqueue *submit_workers;
910 struct btrfs_workqueue *caching_workers;
911 struct btrfs_workqueue *readahead_workers;
Josef Bacikbab39bf2011-06-30 14:42:28 -0400912
Chris Mason247e7432008-07-17 12:53:51 -0400913 /*
914 * fixup workers take dirty pages that didn't properly go through
915 * the cow mechanism and make them safe to write. It happens
916 * for the sys_munmap function call path
917 */
Qu Wenruod458b052014-02-28 10:46:19 +0800918 struct btrfs_workqueue *fixup_workers;
919 struct btrfs_workqueue *delayed_workers;
Chris Masona79b7d42014-05-22 16:18:52 -0700920
921 /* the extent workers do delayed refs on the extent allocation tree */
922 struct btrfs_workqueue *extent_workers;
Chris Masona74a4b92008-06-25 16:01:31 -0400923 struct task_struct *transaction_kthread;
924 struct task_struct *cleaner_kthread;
Chris Mason4543df72008-06-11 21:47:56 -0400925 int thread_pool_size;
Chris Mason8b712842008-06-11 16:50:36 -0400926
Jeff Mahoney6ab0a202013-11-01 13:07:04 -0400927 struct kobject *space_info_kobj;
Chris Mason62e27492007-03-15 12:56:47 -0400928
Yan324ae4d2007-11-16 14:57:08 -0500929 u64 total_pinned;
Chris Masonb9473432009-03-13 11:00:37 -0400930
Miao Xiee2d84522013-01-29 10:09:20 +0000931 /* used to keep from writing metadata until there is a nice batch */
932 struct percpu_counter dirty_metadata_bytes;
Miao Xie963d6782013-01-29 10:10:51 +0000933 struct percpu_counter delalloc_bytes;
Miao Xiee2d84522013-01-29 10:09:20 +0000934 s32 dirty_metadata_batch;
Miao Xie963d6782013-01-29 10:10:51 +0000935 s32 delalloc_batch;
936
Chris Mason0b86a832008-03-24 15:01:56 -0400937 struct list_head dirty_cowonly_roots;
938
Chris Mason8a4b83c2008-03-24 15:02:07 -0400939 struct btrfs_fs_devices *fs_devices;
Chris Mason4184ea72009-03-10 12:39:20 -0400940
941 /*
942 * the space_info list is almost entirely read only. It only changes
943 * when we add a new raid type to the FS, and that happens
944 * very rarely. RCU is used to protect it.
945 */
Chris Mason6324fbf2008-03-24 15:01:59 -0400946 struct list_head space_info;
Chris Mason4184ea72009-03-10 12:39:20 -0400947
Li Zefanb4d7c3c2012-07-09 20:21:07 -0600948 struct btrfs_space_info *data_sinfo;
949
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400950 struct reloc_control *reloc_ctl;
951
Chris Masonfa9c0d792009-04-03 09:47:43 -0400952 /* data_alloc_cluster is only used in ssd mode */
953 struct btrfs_free_cluster data_alloc_cluster;
954
955 /* all metadata allocations go through this cluster */
956 struct btrfs_free_cluster meta_alloc_cluster;
Chris Masond18a2c42008-04-04 15:40:00 -0400957
Chris Mason4cb53002011-05-24 15:35:30 -0400958 /* auto defrag inodes go here */
959 spinlock_t defrag_inodes_lock;
960 struct rb_root defrag_inodes;
961 atomic_t defrag_running;
962
Miao Xiede98ced2013-01-29 10:13:12 +0000963 /* Used to protect avail_{data, metadata, system}_alloc_bits */
964 seqlock_t profiles_lock;
Ilya Dryomova46d11a2012-01-16 22:04:47 +0200965 /*
966 * these three are in extended format (availability of single
967 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
968 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
969 */
Chris Masond18a2c42008-04-04 15:40:00 -0400970 u64 avail_data_alloc_bits;
971 u64 avail_metadata_alloc_bits;
972 u64 avail_system_alloc_bits;
Chris Mason788f20e2008-04-28 15:29:42 -0400973
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200974 /* restriper state */
975 spinlock_t balance_lock;
976 struct mutex balance_mutex;
Ilya Dryomov837d5b62012-01-16 22:04:49 +0200977 atomic_t balance_running;
978 atomic_t balance_pause_req;
Ilya Dryomova7e99c62012-01-16 22:04:49 +0200979 atomic_t balance_cancel_req;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200980 struct btrfs_balance_control *balance_ctl;
Ilya Dryomov837d5b62012-01-16 22:04:49 +0200981 wait_queue_head_t balance_wait_q;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200982
Josef Bacik97e728d2009-04-21 17:40:57 -0400983 unsigned data_chunk_allocations;
984 unsigned metadata_ratio;
985
Chris Mason788f20e2008-04-28 15:29:42 -0400986 void *bdev_holder;
liuboacce9522011-01-06 19:30:25 +0800987
Arne Jansena2de7332011-03-08 14:14:00 +0100988 /* private scrub information */
989 struct mutex scrub_lock;
990 atomic_t scrubs_running;
991 atomic_t scrub_pause_req;
992 atomic_t scrubs_paused;
993 atomic_t scrub_cancel_req;
994 wait_queue_head_t scrub_pause_wait;
Arne Jansena2de7332011-03-08 14:14:00 +0100995 int scrub_workers_refcnt;
Qu Wenruod458b052014-02-28 10:46:19 +0800996 struct btrfs_workqueue *scrub_workers;
997 struct btrfs_workqueue *scrub_wr_completion_workers;
998 struct btrfs_workqueue *scrub_nocow_workers;
Zhao Lei20b2e302015-06-04 20:09:15 +0800999 struct btrfs_workqueue *scrub_parity_workers;
Arne Jansena2de7332011-03-08 14:14:00 +01001000
Stefan Behrens21adbd52011-11-09 13:44:05 +01001001#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1002 u32 check_integrity_print_mask;
1003#endif
Arne Jansen416ac512011-09-13 12:56:09 +02001004 /* is qgroup tracking in a consistent state? */
1005 u64 qgroup_flags;
1006
1007 /* holds configuration and tracking. Protected by qgroup_lock */
1008 struct rb_root qgroup_tree;
Josef Bacikfcebe452014-05-13 17:30:47 -07001009 struct rb_root qgroup_op_tree;
Arne Jansen416ac512011-09-13 12:56:09 +02001010 spinlock_t qgroup_lock;
Josef Bacikfcebe452014-05-13 17:30:47 -07001011 spinlock_t qgroup_op_lock;
1012 atomic_t qgroup_op_seq;
Arne Jansen416ac512011-09-13 12:56:09 +02001013
Wang Shilong1e8f9152013-05-06 11:03:27 +00001014 /*
1015 * used to avoid frequently calling ulist_alloc()/ulist_free()
1016 * when doing qgroup accounting, it must be protected by qgroup_lock.
1017 */
1018 struct ulist *qgroup_ulist;
1019
Wang Shilongf2f6ed32013-04-07 10:50:16 +00001020 /* protect user change for quota operations */
1021 struct mutex qgroup_ioctl_lock;
1022
Arne Jansen416ac512011-09-13 12:56:09 +02001023 /* list of dirty qgroups to be written at next commit */
1024 struct list_head dirty_qgroups;
1025
Qu Wenruoe69bcee2015-04-17 10:23:16 +08001026 /* used by qgroup for an efficient tree traversal */
Arne Jansen416ac512011-09-13 12:56:09 +02001027 u64 qgroup_seq;
Stefan Behrens21adbd52011-11-09 13:44:05 +01001028
Jan Schmidt2f232032013-04-25 16:04:51 +00001029 /* qgroup rescan items */
1030 struct mutex qgroup_rescan_lock; /* protects the progress item */
1031 struct btrfs_key qgroup_rescan_progress;
Qu Wenruod458b052014-02-28 10:46:19 +08001032 struct btrfs_workqueue *qgroup_rescan_workers;
Jan Schmidt57254b6e2013-05-06 19:14:17 +00001033 struct completion qgroup_rescan_completion;
Jan Schmidtb382a322013-05-28 15:47:24 +00001034 struct btrfs_work qgroup_rescan_work;
Jeff Mahoneyd2c609b2016-08-15 12:10:33 -04001035 bool qgroup_rescan_running; /* protected by qgroup_rescan_lock */
Jan Schmidt2f232032013-04-25 16:04:51 +00001036
liuboacce9522011-01-06 19:30:25 +08001037 /* filesystem state */
Miao Xie87533c42013-01-29 10:14:48 +00001038 unsigned long fs_state;
Miao Xie16cdcec2011-04-22 18:12:22 +08001039
1040 struct btrfs_delayed_root *delayed_root;
Chris Masonaf31f5e2011-11-03 15:17:42 -04001041
Arne Jansen90519d62011-05-23 14:30:00 +02001042 /* readahead tree */
1043 spinlock_t reada_lock;
1044 struct radix_tree_root reada_tree;
Chris Mason531f4b1a2011-11-06 03:05:08 -05001045
Zhao Lei2fefd552016-01-07 18:38:48 +08001046 /* readahead works cnt */
1047 atomic_t reada_works_cnt;
1048
Josef Bacikf28491e2013-12-16 13:24:27 -05001049 /* Extent buffer radix tree */
1050 spinlock_t buffer_lock;
1051 struct radix_tree_root buffer_radix;
1052
Chris Masonaf31f5e2011-11-03 15:17:42 -04001053 /* next backup root to be overwritten */
1054 int backup_root_index;
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02001055
1056 int num_tolerated_disk_barrier_failures;
Stefan Behrense922e082012-11-05 17:26:40 +01001057
1058 /* device replace state */
1059 struct btrfs_dev_replace dev_replace;
Stefan Behrens5ac00ad2012-11-05 17:54:08 +01001060
1061 atomic_t mutually_exclusive_operation_running;
Stefan Behrens803b2f52013-08-15 17:11:21 +02001062
Miao Xiec404e0d2014-01-30 16:46:55 +08001063 struct percpu_counter bio_counter;
1064 wait_queue_head_t replace_wait;
1065
Stefan Behrens803b2f52013-08-15 17:11:21 +02001066 struct semaphore uuid_tree_rescan_sem;
Miao Xie21c7e752014-05-13 17:29:04 -07001067
1068 /* Used to reclaim the metadata space in the background. */
1069 struct work_struct async_reclaim_work;
Josef Bacik47ab2a62014-09-18 11:20:02 -04001070
1071 spinlock_t unused_bgs_lock;
1072 struct list_head unused_bgs;
Filipe Mananad4b450c2015-01-29 19:18:25 +00001073 struct mutex unused_bg_unpin_mutex;
Filipe Manana67c5e7d2015-06-11 00:58:53 +01001074 struct mutex delete_unused_bgs_mutex;
Qu Wenruof667aef2014-09-23 13:40:08 +08001075
1076 /* For btrfs to record security options */
1077 struct security_mnt_opts security_opts;
Filipe Manana04216822014-11-27 21:14:15 +00001078
1079 /*
1080 * Chunks that can't be freed yet (under a trim/discard operation)
1081 * and will be latter freed. Protected by fs_info->chunk_mutex.
1082 */
1083 struct list_head pinned_chunks;
Chris Mason511711a2015-12-30 07:52:35 -08001084
Wang Xiaoguang9e7cc912016-08-01 13:28:08 +08001085 /* Used to record internally whether fs has been frozen */
1086 int fs_frozen;
Jeff Mahoneyda170662016-06-15 09:22:56 -04001087
1088 /* Cached block sizes */
1089 u32 nodesize;
1090 u32 sectorsize;
1091 u32 stripesize;
Yan324ae4d2007-11-16 14:57:08 -05001092};
Chris Mason0b86a832008-03-24 15:01:56 -04001093
Jeff Mahoneyda170662016-06-15 09:22:56 -04001094static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
1095{
1096 return sb->s_fs_info;
1097}
1098
Miao Xie8257b2d2014-03-06 13:38:19 +08001099struct btrfs_subvolume_writers {
1100 struct percpu_counter counter;
1101 wait_queue_head_t wait;
1102};
1103
Chris Mason62e27492007-03-15 12:56:47 -04001104/*
Miao Xie27cdeb72014-04-02 19:51:05 +08001105 * The state of btrfs root
1106 */
1107/*
1108 * btrfs_record_root_in_trans is a multi-step process,
1109 * and it can race with the balancing code. But the
1110 * race is very small, and only the first time the root
1111 * is added to each transaction. So IN_TRANS_SETUP
1112 * is used to tell us when more checks are required
1113 */
1114#define BTRFS_ROOT_IN_TRANS_SETUP 0
1115#define BTRFS_ROOT_REF_COWS 1
1116#define BTRFS_ROOT_TRACK_DIRTY 2
1117#define BTRFS_ROOT_IN_RADIX 3
Jeff Mahoneyf5ee5c92016-06-21 09:52:41 -04001118#define BTRFS_ROOT_ORPHAN_ITEM_INSERTED 4
1119#define BTRFS_ROOT_DEFRAG_RUNNING 5
1120#define BTRFS_ROOT_FORCE_COW 6
1121#define BTRFS_ROOT_MULTI_LOG_TASKS 7
1122#define BTRFS_ROOT_DIRTY 8
Miao Xie27cdeb72014-04-02 19:51:05 +08001123
1124/*
Chris Mason62e27492007-03-15 12:56:47 -04001125 * in ram representation of the tree. extent_root is used for all allocations
Chris Masonf2458e12007-04-25 15:52:25 -04001126 * and for the extent tree extent_root root.
Chris Mason62e27492007-03-15 12:56:47 -04001127 */
1128struct btrfs_root {
Chris Mason5f39d392007-10-15 16:14:19 -04001129 struct extent_buffer *node;
Chris Mason925baed2008-06-25 16:01:30 -04001130
Chris Mason5f39d392007-10-15 16:14:19 -04001131 struct extent_buffer *commit_root;
Chris Masone02119d2008-09-05 16:13:11 -04001132 struct btrfs_root *log_root;
Zheng Yan1a40e232008-09-26 10:09:34 -04001133 struct btrfs_root *reloc_root;
Yan Zheng31153d82008-07-28 15:32:19 -04001134
Miao Xie27cdeb72014-04-02 19:51:05 +08001135 unsigned long state;
Chris Mason62e27492007-03-15 12:56:47 -04001136 struct btrfs_root_item root_item;
1137 struct btrfs_key root_key;
Chris Mason9f5fae22007-03-20 14:38:32 -04001138 struct btrfs_fs_info *fs_info;
Chris Masond0c803c2008-09-11 16:17:57 -04001139 struct extent_io_tree dirty_log_pages;
1140
Chris Masona2135012008-06-25 16:01:30 -04001141 struct mutex objectid_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001142
Yan, Zhengf0486c62010-05-16 10:46:25 -04001143 spinlock_t accounting_lock;
1144 struct btrfs_block_rsv *block_rsv;
1145
Li Zefan581bb052011-04-20 10:06:11 +08001146 /* free ino cache stuff */
Li Zefan581bb052011-04-20 10:06:11 +08001147 struct btrfs_free_space_ctl *free_ino_ctl;
David Sterba57cdc8d2014-02-05 02:37:48 +01001148 enum btrfs_caching_type ino_cache_state;
1149 spinlock_t ino_cache_lock;
1150 wait_queue_head_t ino_cache_wait;
Li Zefan581bb052011-04-20 10:06:11 +08001151 struct btrfs_free_space_ctl *free_ino_pinned;
David Sterba57cdc8d2014-02-05 02:37:48 +01001152 u64 ino_cache_progress;
1153 struct inode *ino_cache_inode;
Li Zefan581bb052011-04-20 10:06:11 +08001154
Chris Masone02119d2008-09-05 16:13:11 -04001155 struct mutex log_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001156 wait_queue_head_t log_writer_wait;
1157 wait_queue_head_t log_commit_wait[2];
Miao Xie8b050d32014-02-20 18:08:58 +08001158 struct list_head log_ctxs[2];
Yan Zheng7237f182009-01-21 12:54:03 -05001159 atomic_t log_writers;
1160 atomic_t log_commit[2];
Miao Xie2ecb7922012-09-06 04:04:27 -06001161 atomic_t log_batch;
Miao Xiebb14a592014-02-20 18:08:56 +08001162 int log_transid;
Miao Xied1433de2014-02-20 18:08:59 +08001163 /* No matter the commit succeeds or not*/
1164 int log_transid_committed;
1165 /* Just be updated when the commit succeeds. */
Miao Xiebb14a592014-02-20 18:08:56 +08001166 int last_log_commit;
Josef Bacikff782e02009-10-08 15:30:04 -04001167 pid_t log_start_pid;
Chris Masonea8c2812008-08-04 23:17:27 -04001168
Chris Mason0f7d52f2007-04-09 10:42:37 -04001169 u64 objectid;
1170 u64 last_trans;
Chris Mason5f39d392007-10-15 16:14:19 -04001171
Chris Mason9f5fae22007-03-20 14:38:32 -04001172 u32 type;
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001173
1174 u64 highest_objectid;
Chris Mason75857172011-06-13 20:00:16 -04001175
David Sterba05653ef2016-07-15 15:23:37 +02001176#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
Chris Mason0d4cf4e2014-10-07 13:24:20 -07001177 /* only used with CONFIG_BTRFS_FS_RUN_SANITY_TESTS is enabled */
Josef Bacikfaa2dbf2014-05-07 17:06:09 -04001178 u64 alloc_bytenr;
David Sterba05653ef2016-07-15 15:23:37 +02001179#endif
Josef Bacikfaa2dbf2014-05-07 17:06:09 -04001180
Chris Mason3f157a22008-06-25 16:01:31 -04001181 u64 defrag_trans_start;
Chris Mason6702ed42007-08-07 16:15:09 -04001182 struct btrfs_key defrag_progress;
Chris Mason0ef3e662008-05-24 14:04:53 -04001183 struct btrfs_key defrag_max;
Josef Bacik58176a92007-08-29 15:47:34 -04001184 char *name;
Chris Mason0b86a832008-03-24 15:01:56 -04001185
1186 /* the dirty list is only used by non-reference counted roots */
1187 struct list_head dirty_list;
Josef Bacik7b128762008-07-24 12:17:14 -04001188
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001189 struct list_head root_list;
1190
Josef Bacik2ab28f32012-10-12 15:27:49 -04001191 spinlock_t log_extents_lock[2];
1192 struct list_head logged_list[2];
1193
Yan, Zhengd68fc572010-05-16 10:49:58 -04001194 spinlock_t orphan_lock;
Josef Bacik8a35d952012-05-23 14:26:42 -04001195 atomic_t orphan_inodes;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001196 struct btrfs_block_rsv *orphan_block_rsv;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001197 int orphan_cleanup_state;
Chris Mason3394e162008-11-17 20:42:26 -05001198
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001199 spinlock_t inode_lock;
1200 /* red-black tree that keeps track of in-memory inodes */
1201 struct rb_root inode_tree;
1202
Chris Mason3394e162008-11-17 20:42:26 -05001203 /*
Miao Xie16cdcec2011-04-22 18:12:22 +08001204 * radix tree that keeps track of delayed nodes of every inode,
1205 * protected by inode_lock
1206 */
1207 struct radix_tree_root delayed_nodes_tree;
1208 /*
Chris Mason3394e162008-11-17 20:42:26 -05001209 * right now this just gets used so that a root has its own devid
1210 * for stat. It may be used for more later
1211 */
Al Viro0ee5dc62011-07-07 15:44:25 -04001212 dev_t anon_dev;
Liu Bof1ebcc72011-11-14 20:48:06 -05001213
Anand Jain5f3ab902012-12-07 09:28:54 +00001214 spinlock_t root_item_lock;
Miao Xieb0feb9d2013-05-15 07:48:20 +00001215 atomic_t refs;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001216
Miao Xie573bfb72014-03-06 13:55:03 +08001217 struct mutex delalloc_mutex;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001218 spinlock_t delalloc_lock;
1219 /*
1220 * all of the inodes that have delalloc bytes. It is possible for
1221 * this list to be empty even when there is still dirty data=ordered
1222 * extents waiting to finish IO.
1223 */
1224 struct list_head delalloc_inodes;
1225 struct list_head delalloc_root;
1226 u64 nr_delalloc_inodes;
Miao Xie31f3d252014-03-06 13:55:02 +08001227
1228 struct mutex ordered_extent_mutex;
Miao Xie199c2a92013-05-15 07:48:23 +00001229 /*
1230 * this is used by the balancing code to wait for all the pending
1231 * ordered extents
1232 */
1233 spinlock_t ordered_extent_lock;
1234
1235 /*
1236 * all of the data=ordered extents pending writeback
1237 * these can span multiple transactions and basically include
1238 * every dirty data page that isn't from nodatacow
1239 */
1240 struct list_head ordered_extents;
1241 struct list_head ordered_root;
1242 u64 nr_ordered_extents;
David Sterba2c686532013-12-16 17:34:17 +01001243
1244 /*
1245 * Number of currently running SEND ioctls to prevent
1246 * manipulation with the read-only status via SUBVOL_SETFLAGS
1247 */
1248 int send_in_progress;
Miao Xie8257b2d2014-03-06 13:38:19 +08001249 struct btrfs_subvolume_writers *subv_writers;
1250 atomic_t will_be_snapshoted;
Qu Wenruo55eeaf02015-09-08 17:08:38 +08001251
1252 /* For qgroup metadata space reserve */
1253 atomic_t qgroup_meta_rsv;
Chris Mason62e27492007-03-15 12:56:47 -04001254};
Jeff Mahoneyda170662016-06-15 09:22:56 -04001255static inline u32 btrfs_inode_sectorsize(const struct inode *inode)
1256{
1257 return btrfs_sb(inode->i_sb)->sectorsize;
1258}
Chris Mason62e27492007-03-15 12:56:47 -04001259
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001260static inline u32 __BTRFS_LEAF_DATA_SIZE(u32 blocksize)
1261{
1262 return blocksize - sizeof(struct btrfs_header);
1263}
1264
Jeff Mahoneyda170662016-06-15 09:22:56 -04001265static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001266{
Jeff Mahoneyda170662016-06-15 09:22:56 -04001267 return __BTRFS_LEAF_DATA_SIZE(info->nodesize);
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001268}
1269
Jeff Mahoneyda170662016-06-15 09:22:56 -04001270static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001271{
Jeff Mahoneyda170662016-06-15 09:22:56 -04001272 return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001273}
1274
Jeff Mahoneyda170662016-06-15 09:22:56 -04001275static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001276{
Jeff Mahoneyda170662016-06-15 09:22:56 -04001277 return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001278}
1279
1280#define BTRFS_FILE_EXTENT_INLINE_DATA_START \
1281 (offsetof(struct btrfs_file_extent_item, disk_bytenr))
Jeff Mahoneyda170662016-06-15 09:22:56 -04001282static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001283{
Jeff Mahoneyda170662016-06-15 09:22:56 -04001284 return BTRFS_MAX_ITEM_SIZE(info) -
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001285 BTRFS_FILE_EXTENT_INLINE_DATA_START;
1286}
1287
Jeff Mahoneyda170662016-06-15 09:22:56 -04001288static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001289{
Jeff Mahoneyda170662016-06-15 09:22:56 -04001290 return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
Jeff Mahoney1db1ff92016-06-15 10:33:06 -04001291}
1292
David Sterba0942caa2011-06-28 15:10:37 +00001293/*
1294 * Flags for mount options.
1295 *
1296 * Note: don't forget to add new options to btrfs_show_options()
1297 */
Chris Mason21ad10c2008-01-09 09:23:21 -05001298#define BTRFS_MOUNT_NODATASUM (1 << 0)
1299#define BTRFS_MOUNT_NODATACOW (1 << 1)
1300#define BTRFS_MOUNT_NOBARRIER (1 << 2)
Chris Masone18e4802008-01-18 10:54:22 -05001301#define BTRFS_MOUNT_SSD (1 << 3)
Chris Masondfe25022008-05-13 13:46:40 -04001302#define BTRFS_MOUNT_DEGRADED (1 << 4)
Chris Masonc8b97812008-10-29 14:49:59 -04001303#define BTRFS_MOUNT_COMPRESS (1 << 5)
Sage Weil3a5e1402009-04-02 16:49:40 -04001304#define BTRFS_MOUNT_NOTREELOG (1 << 6)
Sage Weildccae992009-04-02 16:59:01 -04001305#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
Chris Mason451d7582009-06-09 20:28:34 -04001306#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
Chris Masonc2898112009-06-10 09:51:32 -04001307#define BTRFS_MOUNT_NOSSD (1 << 9)
Christoph Hellwige244a0a2009-10-14 09:24:59 -04001308#define BTRFS_MOUNT_DISCARD (1 << 10)
Chris Masona555f812010-01-28 16:18:15 -05001309#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
Josef Bacik0af3d002010-06-21 14:48:16 -04001310#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
Josef Bacik88c2ba32010-09-21 14:21:34 -04001311#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
Sage Weil4260f7c2010-10-29 15:46:43 -04001312#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
Chris Mason91435652011-02-16 13:10:41 -05001313#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
Chris Mason4cb53002011-05-24 15:35:30 -04001314#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
Chris Mason4b9465c2011-06-03 09:36:29 -04001315#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
Qu Wenruo8dcddfa2016-01-19 10:23:02 +08001316#define BTRFS_MOUNT_USEBACKUPROOT (1 << 18)
Ilya Dryomov9555c6c2012-01-16 22:04:48 +02001317#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
Chris Masonc126dea2012-01-16 15:27:58 -05001318#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
1319#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
Jeff Mahoney8c342932011-10-03 23:22:31 -04001320#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22)
Stefan Behrensf420ee12013-08-15 17:11:24 +02001321#define BTRFS_MOUNT_RESCAN_UUID_TREE (1 << 23)
Josef Bacikd0bd4562015-09-23 14:54:14 -04001322#define BTRFS_MOUNT_FRAGMENT_DATA (1 << 24)
1323#define BTRFS_MOUNT_FRAGMENT_METADATA (1 << 25)
Chris Masonf7d3d2f2015-12-18 11:11:10 -08001324#define BTRFS_MOUNT_FREE_SPACE_TREE (1 << 26)
Qu Wenruo96da0912016-01-19 10:23:03 +08001325#define BTRFS_MOUNT_NOLOGREPLAY (1 << 27)
Chris Masonb6cda9b2007-12-14 15:30:32 -05001326
David Sterba8b87dc12013-08-01 18:14:52 +02001327#define BTRFS_DEFAULT_COMMIT_INTERVAL (30)
David Sterbaf7e98a72015-10-08 14:14:16 +02001328#define BTRFS_DEFAULT_MAX_INLINE (2048)
David Sterba8b87dc12013-08-01 18:14:52 +02001329
Chris Masonb6cda9b2007-12-14 15:30:32 -05001330#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
1331#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
Miao Xiedc81cdc2013-02-20 23:32:52 -07001332#define btrfs_raw_test_opt(o, opt) ((o) & BTRFS_MOUNT_##opt)
Jeff Mahoney3cdde222016-06-09 21:38:35 -04001333#define btrfs_test_opt(fs_info, opt) ((fs_info)->mount_opt & \
Chris Masonb6cda9b2007-12-14 15:30:32 -05001334 BTRFS_MOUNT_##opt)
David Sterba572d9ab2014-02-05 15:26:17 +01001335
Jeff Mahoney3cdde222016-06-09 21:38:35 -04001336#define btrfs_set_and_info(fs_info, opt, fmt, args...) \
Wang Shilong9d89ce62014-04-23 19:33:33 +08001337{ \
Jeff Mahoney3cdde222016-06-09 21:38:35 -04001338 if (!btrfs_test_opt(fs_info, opt)) \
1339 btrfs_info(fs_info, fmt, ##args); \
1340 btrfs_set_opt(fs_info->mount_opt, opt); \
Wang Shilong9d89ce62014-04-23 19:33:33 +08001341}
1342
Jeff Mahoney3cdde222016-06-09 21:38:35 -04001343#define btrfs_clear_and_info(fs_info, opt, fmt, args...) \
Wang Shilong9d89ce62014-04-23 19:33:33 +08001344{ \
Jeff Mahoney3cdde222016-06-09 21:38:35 -04001345 if (btrfs_test_opt(fs_info, opt)) \
1346 btrfs_info(fs_info, fmt, ##args); \
1347 btrfs_clear_opt(fs_info->mount_opt, opt); \
Wang Shilong9d89ce62014-04-23 19:33:33 +08001348}
1349
Josef Bacikd0bd4562015-09-23 14:54:14 -04001350#ifdef CONFIG_BTRFS_DEBUG
1351static inline int
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001352btrfs_should_fragment_free_space(struct btrfs_block_group_cache *block_group)
Josef Bacikd0bd4562015-09-23 14:54:14 -04001353{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001354 struct btrfs_fs_info *fs_info = block_group->fs_info;
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001355
1356 return (btrfs_test_opt(fs_info, FRAGMENT_METADATA) &&
Josef Bacikd0bd4562015-09-23 14:54:14 -04001357 block_group->flags & BTRFS_BLOCK_GROUP_METADATA) ||
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001358 (btrfs_test_opt(fs_info, FRAGMENT_DATA) &&
Josef Bacikd0bd4562015-09-23 14:54:14 -04001359 block_group->flags & BTRFS_BLOCK_GROUP_DATA);
1360}
1361#endif
1362
Yanb98b6762008-01-08 15:54:37 -05001363/*
David Sterba572d9ab2014-02-05 15:26:17 +01001364 * Requests for changes that need to be done during transaction commit.
1365 *
1366 * Internal mount options that are used for special handling of the real
1367 * mount options (eg. cannot be set during remount and have to be set during
1368 * transaction commit)
1369 */
1370
David Sterba7e1876a2014-02-05 15:26:17 +01001371#define BTRFS_PENDING_SET_INODE_MAP_CACHE (0)
1372#define BTRFS_PENDING_CLEAR_INODE_MAP_CACHE (1)
David Sterbad51033d2014-11-12 14:24:35 +01001373#define BTRFS_PENDING_COMMIT (2)
David Sterba7e1876a2014-02-05 15:26:17 +01001374
David Sterba572d9ab2014-02-05 15:26:17 +01001375#define btrfs_test_pending(info, opt) \
1376 test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1377#define btrfs_set_pending(info, opt) \
1378 set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1379#define btrfs_clear_pending(info, opt) \
1380 clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1381
1382/*
1383 * Helpers for setting pending mount option changes.
1384 *
1385 * Expects corresponding macros
1386 * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name
1387 */
1388#define btrfs_set_pending_and_info(info, opt, fmt, args...) \
1389do { \
1390 if (!btrfs_raw_test_opt((info)->mount_opt, opt)) { \
1391 btrfs_info((info), fmt, ##args); \
1392 btrfs_set_pending((info), SET_##opt); \
1393 btrfs_clear_pending((info), CLEAR_##opt); \
1394 } \
1395} while(0)
1396
1397#define btrfs_clear_pending_and_info(info, opt, fmt, args...) \
1398do { \
1399 if (btrfs_raw_test_opt((info)->mount_opt, opt)) { \
1400 btrfs_info((info), fmt, ##args); \
1401 btrfs_set_pending((info), CLEAR_##opt); \
1402 btrfs_clear_pending((info), SET_##opt); \
1403 } \
1404} while(0)
1405
1406/*
Yanb98b6762008-01-08 15:54:37 -05001407 * Inode flags
1408 */
Yanfdebe2b2008-01-14 13:26:08 -05001409#define BTRFS_INODE_NODATASUM (1 << 0)
1410#define BTRFS_INODE_NODATACOW (1 << 1)
1411#define BTRFS_INODE_READONLY (1 << 2)
Chris Masonc8b97812008-10-29 14:49:59 -04001412#define BTRFS_INODE_NOCOMPRESS (1 << 3)
Yan Zhengd899e052008-10-30 14:25:28 -04001413#define BTRFS_INODE_PREALLOC (1 << 4)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02001414#define BTRFS_INODE_SYNC (1 << 5)
1415#define BTRFS_INODE_IMMUTABLE (1 << 6)
1416#define BTRFS_INODE_APPEND (1 << 7)
1417#define BTRFS_INODE_NODUMP (1 << 8)
1418#define BTRFS_INODE_NOATIME (1 << 9)
1419#define BTRFS_INODE_DIRSYNC (1 << 10)
Liu Bo75e7cb72011-03-22 10:12:20 +00001420#define BTRFS_INODE_COMPRESS (1 << 11)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02001421
Li Zefan08fe4db2011-03-28 02:01:25 +00001422#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
1423
Chris Masoncfed81a2012-03-03 07:40:03 -05001424struct btrfs_map_token {
1425 struct extent_buffer *eb;
1426 char *kaddr;
1427 unsigned long offset;
1428};
1429
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301430#define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1431 ((bytes) >> (fs_info)->sb->s_blocksize_bits)
1432
Chris Masoncfed81a2012-03-03 07:40:03 -05001433static inline void btrfs_init_map_token (struct btrfs_map_token *token)
1434{
Josef Bacikad914552012-10-15 13:39:33 -04001435 token->kaddr = NULL;
Chris Masoncfed81a2012-03-03 07:40:03 -05001436}
1437
Nicholas D Steeves01327612016-05-19 21:18:45 -04001438/* some macros to generate set/get functions for the struct fields. This
Chris Mason5f39d392007-10-15 16:14:19 -04001439 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1440 * one for u8:
1441 */
1442#define le8_to_cpu(v) (v)
1443#define cpu_to_le8(v) (v)
1444#define __le8 u8
Chris Mason9078a3e2007-04-26 16:46:15 -04001445
Jeff Mahoney62e85572016-09-20 10:05:01 -04001446#define read_eb_member(eb, ptr, type, member, result) (\
Chris Mason5f39d392007-10-15 16:14:19 -04001447 read_extent_buffer(eb, (char *)(result), \
1448 ((unsigned long)(ptr)) + \
1449 offsetof(type, member), \
1450 sizeof(((type *)0)->member)))
1451
Jeff Mahoney62e85572016-09-20 10:05:01 -04001452#define write_eb_member(eb, ptr, type, member, result) (\
Chris Mason5f39d392007-10-15 16:14:19 -04001453 write_extent_buffer(eb, (char *)(result), \
1454 ((unsigned long)(ptr)) + \
1455 offsetof(type, member), \
1456 sizeof(((type *)0)->member)))
1457
Li Zefan18077bb2012-07-09 20:22:35 -06001458#define DECLARE_BTRFS_SETGET_BITS(bits) \
1459u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr, \
1460 unsigned long off, \
1461 struct btrfs_map_token *token); \
1462void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr, \
1463 unsigned long off, u##bits val, \
1464 struct btrfs_map_token *token); \
1465static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \
1466 unsigned long off) \
1467{ \
1468 return btrfs_get_token_##bits(eb, ptr, off, NULL); \
1469} \
1470static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \
1471 unsigned long off, u##bits val) \
1472{ \
1473 btrfs_set_token_##bits(eb, ptr, off, val, NULL); \
1474}
1475
1476DECLARE_BTRFS_SETGET_BITS(8)
1477DECLARE_BTRFS_SETGET_BITS(16)
1478DECLARE_BTRFS_SETGET_BITS(32)
1479DECLARE_BTRFS_SETGET_BITS(64)
1480
Chris Mason5f39d392007-10-15 16:14:19 -04001481#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
Li Zefan18077bb2012-07-09 20:22:35 -06001482static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s) \
1483{ \
1484 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1485 return btrfs_get_##bits(eb, s, offsetof(type, member)); \
1486} \
1487static inline void btrfs_set_##name(struct extent_buffer *eb, type *s, \
1488 u##bits val) \
1489{ \
1490 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1491 btrfs_set_##bits(eb, s, offsetof(type, member), val); \
1492} \
1493static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \
1494 struct btrfs_map_token *token) \
1495{ \
1496 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1497 return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
1498} \
1499static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
1500 type *s, u##bits val, \
1501 struct btrfs_map_token *token) \
1502{ \
1503 BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member); \
1504 btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
1505}
Chris Mason9078a3e2007-04-26 16:46:15 -04001506
Chris Mason5f39d392007-10-15 16:14:19 -04001507#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
1508static inline u##bits btrfs_##name(struct extent_buffer *eb) \
1509{ \
Chris Mason727011e2010-08-06 13:21:20 -04001510 type *p = page_address(eb->pages[0]); \
David Millerdf68b8a2008-02-15 10:40:52 -05001511 u##bits res = le##bits##_to_cpu(p->member); \
Chris Mason810191f2007-10-15 16:18:55 -04001512 return res; \
Chris Mason5f39d392007-10-15 16:14:19 -04001513} \
1514static inline void btrfs_set_##name(struct extent_buffer *eb, \
1515 u##bits val) \
1516{ \
Chris Mason727011e2010-08-06 13:21:20 -04001517 type *p = page_address(eb->pages[0]); \
David Millerdf68b8a2008-02-15 10:40:52 -05001518 p->member = cpu_to_le##bits(val); \
Chris Mason9078a3e2007-04-26 16:46:15 -04001519}
Chris Mason1e1d2702007-03-15 19:03:33 -04001520
Chris Mason5f39d392007-10-15 16:14:19 -04001521#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
1522static inline u##bits btrfs_##name(type *s) \
1523{ \
1524 return le##bits##_to_cpu(s->member); \
1525} \
1526static inline void btrfs_set_##name(type *s, u##bits val) \
1527{ \
1528 s->member = cpu_to_le##bits(val); \
Chris Mason1e1d2702007-03-15 19:03:33 -04001529}
1530
Chris Mason0b86a832008-03-24 15:01:56 -04001531BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1532BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
1533BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1534BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1535BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
Chris Masonc3027eb2008-12-08 16:40:21 -05001536BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1537 start_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001538BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1539BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001540BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1541BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1542BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05001543BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001544
Chris Mason8a4b83c2008-03-24 15:02:07 -04001545BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1546BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1547 total_bytes, 64);
1548BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1549 bytes_used, 64);
1550BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1551 io_align, 32);
1552BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1553 io_width, 32);
1554BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1555 sector_size, 32);
1556BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001557BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1558 dev_group, 32);
1559BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1560 seek_speed, 8);
1561BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1562 bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05001563BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1564 generation, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04001565
Geert Uytterhoeven410ba3a2013-08-20 13:20:11 +02001566static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
Chris Mason0b86a832008-03-24 15:01:56 -04001567{
Geert Uytterhoeven410ba3a2013-08-20 13:20:11 +02001568 return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
Chris Mason0b86a832008-03-24 15:01:56 -04001569}
1570
Geert Uytterhoeven1473b242013-08-20 13:20:12 +02001571static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
Yan Zheng2b820322008-11-17 21:11:30 -05001572{
Geert Uytterhoeven1473b242013-08-20 13:20:12 +02001573 return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
Yan Zheng2b820322008-11-17 21:11:30 -05001574}
1575
Chris Masone17cade2008-04-15 15:41:47 -04001576BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001577BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1578BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1579BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1580BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1581BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1582BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1583BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04001584BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04001585BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1586BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1587
Chris Masone17cade2008-04-15 15:41:47 -04001588static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1589{
1590 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1591}
1592
1593BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001594BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1595BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1596 stripe_len, 64);
1597BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1598 io_align, 32);
1599BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1600 io_width, 32);
1601BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1602 sector_size, 32);
1603BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1604BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1605 num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04001606BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1607 sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04001608BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1609BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1610
1611static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1612 int nr)
1613{
1614 unsigned long offset = (unsigned long)c;
1615 offset += offsetof(struct btrfs_chunk, stripe);
1616 offset += nr * sizeof(struct btrfs_stripe);
1617 return (struct btrfs_stripe *)offset;
1618}
1619
Chris Masona4437552008-04-18 10:29:38 -04001620static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1621{
1622 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1623}
1624
Chris Mason0b86a832008-03-24 15:01:56 -04001625static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
1626 struct btrfs_chunk *c, int nr)
1627{
1628 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1629}
1630
Chris Mason0b86a832008-03-24 15:01:56 -04001631static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
1632 struct btrfs_chunk *c, int nr)
1633{
1634 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1635}
1636
Chris Mason5f39d392007-10-15 16:14:19 -04001637/* struct btrfs_block_group_item */
1638BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1639 used, 64);
1640BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1641 used, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001642BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1643 struct btrfs_block_group_item, chunk_objectid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001644
1645BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
Chris Mason0b86a832008-03-24 15:01:56 -04001646 struct btrfs_block_group_item, chunk_objectid, 64);
1647BTRFS_SETGET_FUNCS(disk_block_group_flags,
1648 struct btrfs_block_group_item, flags, 64);
1649BTRFS_SETGET_STACK_FUNCS(block_group_flags,
1650 struct btrfs_block_group_item, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001651
Omar Sandoval208acb82015-09-29 20:50:34 -07001652/* struct btrfs_free_space_info */
1653BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
1654 extent_count, 32);
1655BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);
1656
Chris Mason39544012007-12-12 14:38:19 -05001657/* struct btrfs_inode_ref */
1658BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
Josef Bacikaec74772008-07-24 12:12:38 -04001659BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
Chris Mason39544012007-12-12 14:38:19 -05001660
Mark Fashehf1863732012-08-08 11:32:27 -07001661/* struct btrfs_inode_extref */
1662BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
1663 parent_objectid, 64);
1664BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
1665 name_len, 16);
1666BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
1667
Chris Mason5f39d392007-10-15 16:14:19 -04001668/* struct btrfs_inode_item */
1669BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05001670BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
Chris Masone02119d2008-09-05 16:13:11 -04001671BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001672BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
Yan Zhenga76a3cd2008-10-09 11:46:29 -04001673BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001674BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1675BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1676BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1677BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1678BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
Chris Mason0b86a832008-03-24 15:01:56 -04001679BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05001680BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001681BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
1682 generation, 64);
1683BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
1684 sequence, 64);
1685BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
1686 transid, 64);
1687BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
1688BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
1689 nbytes, 64);
1690BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
1691 block_group, 64);
1692BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
1693BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
1694BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
1695BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
1696BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
1697BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001698BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1699BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001700BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
1701BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001702
Chris Mason0b86a832008-03-24 15:01:56 -04001703/* struct btrfs_dev_extent */
Chris Masone17cade2008-04-15 15:41:47 -04001704BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1705 chunk_tree, 64);
1706BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1707 chunk_objectid, 64);
1708BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1709 chunk_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001710BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1711
Geert Uytterhoeven231e88f2013-08-20 13:20:13 +02001712static inline unsigned long btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
Chris Masone17cade2008-04-15 15:41:47 -04001713{
1714 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
Geert Uytterhoeven231e88f2013-08-20 13:20:13 +02001715 return (unsigned long)dev + ptr;
Chris Masone17cade2008-04-15 15:41:47 -04001716}
1717
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001718BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1719BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1720 generation, 64);
1721BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
Chris Mason74493f72007-12-11 09:25:06 -05001722
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001723BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001724
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001725
1726BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1727
1728static inline void btrfs_tree_block_key(struct extent_buffer *eb,
1729 struct btrfs_tree_block_info *item,
1730 struct btrfs_disk_key *key)
1731{
1732 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1733}
1734
1735static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
1736 struct btrfs_tree_block_info *item,
1737 struct btrfs_disk_key *key)
1738{
1739 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1740}
1741
1742BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1743 root, 64);
1744BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1745 objectid, 64);
1746BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1747 offset, 64);
1748BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1749 count, 32);
1750
1751BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1752 count, 32);
1753
1754BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1755 type, 8);
1756BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1757 offset, 64);
1758
1759static inline u32 btrfs_extent_inline_ref_size(int type)
1760{
1761 if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1762 type == BTRFS_SHARED_BLOCK_REF_KEY)
1763 return sizeof(struct btrfs_extent_inline_ref);
1764 if (type == BTRFS_SHARED_DATA_REF_KEY)
1765 return sizeof(struct btrfs_shared_data_ref) +
1766 sizeof(struct btrfs_extent_inline_ref);
1767 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1768 return sizeof(struct btrfs_extent_data_ref) +
1769 offsetof(struct btrfs_extent_inline_ref, offset);
1770 BUG();
1771 return 0;
1772}
1773
1774BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1775BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1776 generation, 64);
1777BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1778BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001779
1780/* struct btrfs_node */
1781BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
Chris Mason74493f72007-12-11 09:25:06 -05001782BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001783BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
1784 blockptr, 64);
1785BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1786 generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001787
1788static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001789{
Chris Mason5f39d392007-10-15 16:14:19 -04001790 unsigned long ptr;
1791 ptr = offsetof(struct btrfs_node, ptrs) +
1792 sizeof(struct btrfs_key_ptr) * nr;
1793 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
Chris Mason1e1d2702007-03-15 19:03:33 -04001794}
1795
Chris Mason5f39d392007-10-15 16:14:19 -04001796static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
1797 int nr, u64 val)
Chris Mason31f3c992007-04-30 15:25:45 -04001798{
Chris Mason5f39d392007-10-15 16:14:19 -04001799 unsigned long ptr;
1800 ptr = offsetof(struct btrfs_node, ptrs) +
1801 sizeof(struct btrfs_key_ptr) * nr;
1802 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
Chris Mason31f3c992007-04-30 15:25:45 -04001803}
1804
Chris Mason74493f72007-12-11 09:25:06 -05001805static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
1806{
1807 unsigned long ptr;
1808 ptr = offsetof(struct btrfs_node, ptrs) +
1809 sizeof(struct btrfs_key_ptr) * nr;
1810 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1811}
1812
1813static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
1814 int nr, u64 val)
1815{
1816 unsigned long ptr;
1817 ptr = offsetof(struct btrfs_node, ptrs) +
1818 sizeof(struct btrfs_key_ptr) * nr;
1819 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1820}
1821
Chris Mason810191f2007-10-15 16:18:55 -04001822static inline unsigned long btrfs_node_key_ptr_offset(int nr)
Chris Mason31f3c992007-04-30 15:25:45 -04001823{
Chris Mason5f39d392007-10-15 16:14:19 -04001824 return offsetof(struct btrfs_node, ptrs) +
1825 sizeof(struct btrfs_key_ptr) * nr;
Chris Mason31f3c992007-04-30 15:25:45 -04001826}
1827
Chris Masone644d022007-11-06 15:09:29 -05001828void btrfs_node_key(struct extent_buffer *eb,
1829 struct btrfs_disk_key *disk_key, int nr);
1830
Chris Mason5f39d392007-10-15 16:14:19 -04001831static inline void btrfs_set_node_key(struct extent_buffer *eb,
1832 struct btrfs_disk_key *disk_key, int nr)
1833{
1834 unsigned long ptr;
1835 ptr = btrfs_node_key_ptr_offset(nr);
1836 write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
1837 struct btrfs_key_ptr, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001838}
1839
Chris Mason5f39d392007-10-15 16:14:19 -04001840/* struct btrfs_item */
1841BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1842BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001843BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
1844BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001845
1846static inline unsigned long btrfs_item_nr_offset(int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001847{
Chris Mason5f39d392007-10-15 16:14:19 -04001848 return offsetof(struct btrfs_leaf, items) +
1849 sizeof(struct btrfs_item) * nr;
Chris Mason1e1d2702007-03-15 19:03:33 -04001850}
1851
Ross Kirkdd3cc162013-09-16 15:58:09 +01001852static inline struct btrfs_item *btrfs_item_nr(int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001853{
Chris Mason5f39d392007-10-15 16:14:19 -04001854 return (struct btrfs_item *)btrfs_item_nr_offset(nr);
Chris Mason1e1d2702007-03-15 19:03:33 -04001855}
1856
Chris Mason5f39d392007-10-15 16:14:19 -04001857static inline u32 btrfs_item_end(struct extent_buffer *eb,
1858 struct btrfs_item *item)
Chris Mason1e1d2702007-03-15 19:03:33 -04001859{
Chris Mason5f39d392007-10-15 16:14:19 -04001860 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
Chris Mason1e1d2702007-03-15 19:03:33 -04001861}
1862
Chris Mason5f39d392007-10-15 16:14:19 -04001863static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001864{
Ross Kirkdd3cc162013-09-16 15:58:09 +01001865 return btrfs_item_end(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001866}
1867
Chris Mason5f39d392007-10-15 16:14:19 -04001868static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001869{
Ross Kirkdd3cc162013-09-16 15:58:09 +01001870 return btrfs_item_offset(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001871}
1872
Chris Mason5f39d392007-10-15 16:14:19 -04001873static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001874{
Ross Kirkdd3cc162013-09-16 15:58:09 +01001875 return btrfs_item_size(eb, btrfs_item_nr(nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001876}
1877
Chris Mason5f39d392007-10-15 16:14:19 -04001878static inline void btrfs_item_key(struct extent_buffer *eb,
1879 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001880{
Ross Kirkdd3cc162013-09-16 15:58:09 +01001881 struct btrfs_item *item = btrfs_item_nr(nr);
Chris Mason5f39d392007-10-15 16:14:19 -04001882 read_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001883}
1884
Chris Mason5f39d392007-10-15 16:14:19 -04001885static inline void btrfs_set_item_key(struct extent_buffer *eb,
1886 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001887{
Ross Kirkdd3cc162013-09-16 15:58:09 +01001888 struct btrfs_item *item = btrfs_item_nr(nr);
Chris Mason5f39d392007-10-15 16:14:19 -04001889 write_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001890}
1891
Chris Masone02119d2008-09-05 16:13:11 -04001892BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1893
Chris Mason0660b5a2008-11-17 20:37:39 -05001894/*
1895 * struct btrfs_root_ref
1896 */
1897BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
1898BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
1899BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
1900
Chris Mason5f39d392007-10-15 16:14:19 -04001901/* struct btrfs_dir_item */
Josef Bacik5103e942007-11-16 11:45:54 -05001902BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
Chris Mason5f39d392007-10-15 16:14:19 -04001903BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
1904BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
Chris Masone02119d2008-09-05 16:13:11 -04001905BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001906BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
1907BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
1908 data_len, 16);
1909BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
1910 name_len, 16);
1911BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
1912 transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001913
1914static inline void btrfs_dir_item_key(struct extent_buffer *eb,
1915 struct btrfs_dir_item *item,
1916 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04001917{
Chris Mason5f39d392007-10-15 16:14:19 -04001918 read_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001919}
1920
Chris Mason5f39d392007-10-15 16:14:19 -04001921static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
1922 struct btrfs_dir_item *item,
1923 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04001924{
Chris Mason5f39d392007-10-15 16:14:19 -04001925 write_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001926}
1927
Josef Bacik0af3d002010-06-21 14:48:16 -04001928BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
1929 num_entries, 64);
1930BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
1931 num_bitmaps, 64);
1932BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
1933 generation, 64);
1934
1935static inline void btrfs_free_space_key(struct extent_buffer *eb,
1936 struct btrfs_free_space_header *h,
1937 struct btrfs_disk_key *key)
1938{
1939 read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1940}
1941
1942static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
1943 struct btrfs_free_space_header *h,
1944 struct btrfs_disk_key *key)
1945{
1946 write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1947}
1948
Chris Mason5f39d392007-10-15 16:14:19 -04001949/* struct btrfs_disk_key */
1950BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
1951 objectid, 64);
1952BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
1953BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
Chris Mason1d4f6402007-03-15 15:18:43 -04001954
Chris Masone2fa7222007-03-12 16:22:34 -04001955static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
1956 struct btrfs_disk_key *disk)
1957{
1958 cpu->offset = le64_to_cpu(disk->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04001959 cpu->type = disk->type;
Chris Masone2fa7222007-03-12 16:22:34 -04001960 cpu->objectid = le64_to_cpu(disk->objectid);
1961}
1962
1963static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
1964 struct btrfs_key *cpu)
1965{
1966 disk->offset = cpu_to_le64(cpu->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04001967 disk->type = cpu->type;
Chris Masone2fa7222007-03-12 16:22:34 -04001968 disk->objectid = cpu_to_le64(cpu->objectid);
1969}
1970
Chris Mason5f39d392007-10-15 16:14:19 -04001971static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
1972 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04001973{
Chris Mason5f39d392007-10-15 16:14:19 -04001974 struct btrfs_disk_key disk_key;
1975 btrfs_node_key(eb, &disk_key, nr);
1976 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04001977}
1978
Chris Mason5f39d392007-10-15 16:14:19 -04001979static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
1980 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04001981{
Chris Mason5f39d392007-10-15 16:14:19 -04001982 struct btrfs_disk_key disk_key;
1983 btrfs_item_key(eb, &disk_key, nr);
1984 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04001985}
1986
Chris Mason5f39d392007-10-15 16:14:19 -04001987static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
1988 struct btrfs_dir_item *item,
1989 struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04001990{
Chris Mason5f39d392007-10-15 16:14:19 -04001991 struct btrfs_disk_key disk_key;
1992 btrfs_dir_item_key(eb, item, &disk_key);
1993 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04001994}
1995
Chris Mason5f39d392007-10-15 16:14:19 -04001996
1997static inline u8 btrfs_key_type(struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04001998{
Chris Mason5f39d392007-10-15 16:14:19 -04001999 return key->type;
Chris Masone2fa7222007-03-12 16:22:34 -04002000}
2001
Chris Mason5f39d392007-10-15 16:14:19 -04002002static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
Chris Masone2fa7222007-03-12 16:22:34 -04002003{
Chris Mason5f39d392007-10-15 16:14:19 -04002004 key->type = val;
Chris Masone2fa7222007-03-12 16:22:34 -04002005}
2006
Chris Mason5f39d392007-10-15 16:14:19 -04002007/* struct btrfs_header */
Chris Masondb945352007-10-15 16:15:53 -04002008BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002009BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2010 generation, 64);
2011BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2012BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
Chris Mason63b10fc2008-04-01 11:21:32 -04002013BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002014BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002015BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
2016 generation, 64);
2017BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
2018BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
2019 nritems, 32);
2020BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002021
Chris Mason63b10fc2008-04-01 11:21:32 -04002022static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
2023{
2024 return (btrfs_header_flags(eb) & flag) == flag;
2025}
2026
2027static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2028{
2029 u64 flags = btrfs_header_flags(eb);
2030 btrfs_set_header_flags(eb, flags | flag);
2031 return (flags & flag) == flag;
2032}
2033
2034static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2035{
2036 u64 flags = btrfs_header_flags(eb);
2037 btrfs_set_header_flags(eb, flags & ~flag);
2038 return (flags & flag) == flag;
2039}
2040
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002041static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
2042{
2043 u64 flags = btrfs_header_flags(eb);
2044 return flags >> BTRFS_BACKREF_REV_SHIFT;
2045}
2046
2047static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2048 int rev)
2049{
2050 u64 flags = btrfs_header_flags(eb);
2051 flags &= ~BTRFS_BACKREF_REV_MASK;
2052 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2053 btrfs_set_header_flags(eb, flags);
2054}
2055
Ross Kirk0a4e5582013-09-24 10:12:38 +01002056static inline unsigned long btrfs_header_fsid(void)
Chris Masone2fa7222007-03-12 16:22:34 -04002057{
Geert Uytterhoevenfba6aa72013-08-20 13:20:14 +02002058 return offsetof(struct btrfs_header, fsid);
Chris Masone2fa7222007-03-12 16:22:34 -04002059}
2060
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02002061static inline unsigned long btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
Chris Masone17cade2008-04-15 15:41:47 -04002062{
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02002063 return offsetof(struct btrfs_header, chunk_tree_uuid);
Chris Masone17cade2008-04-15 15:41:47 -04002064}
2065
Chris Mason5f39d392007-10-15 16:14:19 -04002066static inline int btrfs_is_leaf(struct extent_buffer *eb)
Chris Mason7518a232007-03-12 12:01:18 -04002067{
Chris Masond3977122009-01-05 21:25:51 -05002068 return btrfs_header_level(eb) == 0;
Chris Mason7518a232007-03-12 12:01:18 -04002069}
2070
Chris Mason5f39d392007-10-15 16:14:19 -04002071/* struct btrfs_root_item */
Yan Zheng84234f32008-10-29 14:49:05 -04002072BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2073 generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002074BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
Chris Masondb945352007-10-15 16:15:53 -04002075BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2076BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002077
Yan Zheng84234f32008-10-29 14:49:05 -04002078BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2079 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002080BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2081BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002082BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2083BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002084BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
Chris Masondb945352007-10-15 16:15:53 -04002085BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2086BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
Yan Zheng80ff3852008-10-30 14:20:02 -04002087BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2088 last_snapshot, 64);
Alexander Block8ea05e32012-07-25 17:35:53 +02002089BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2090 generation_v2, 64);
2091BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2092 ctransid, 64);
2093BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2094 otransid, 64);
2095BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2096 stransid, 64);
2097BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2098 rtransid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002099
Li Zefanb83cc962010-12-20 16:04:08 +08002100static inline bool btrfs_root_readonly(struct btrfs_root *root)
2101{
Al Viro6ed3cf2c2012-04-13 11:49:04 -04002102 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
Li Zefanb83cc962010-12-20 16:04:08 +08002103}
2104
David Sterba521e0542014-04-15 16:41:44 +02002105static inline bool btrfs_root_dead(struct btrfs_root *root)
2106{
2107 return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
2108}
2109
Chris Masonaf31f5e2011-11-03 15:17:42 -04002110/* struct btrfs_root_backup */
2111BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2112 tree_root, 64);
2113BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2114 tree_root_gen, 64);
2115BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2116 tree_root_level, 8);
2117
2118BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2119 chunk_root, 64);
2120BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2121 chunk_root_gen, 64);
2122BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2123 chunk_root_level, 8);
2124
2125BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2126 extent_root, 64);
2127BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2128 extent_root_gen, 64);
2129BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2130 extent_root_level, 8);
2131
2132BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2133 fs_root, 64);
2134BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2135 fs_root_gen, 64);
2136BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2137 fs_root_level, 8);
2138
2139BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2140 dev_root, 64);
2141BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2142 dev_root_gen, 64);
2143BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2144 dev_root_level, 8);
2145
2146BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2147 csum_root, 64);
2148BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2149 csum_root_gen, 64);
2150BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2151 csum_root_level, 8);
2152BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2153 total_bytes, 64);
2154BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2155 bytes_used, 64);
2156BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2157 num_devices, 64);
2158
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002159/* struct btrfs_balance_item */
2160BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002161
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002162static inline void btrfs_balance_data(struct extent_buffer *eb,
2163 struct btrfs_balance_item *bi,
2164 struct btrfs_disk_balance_args *ba)
2165{
2166 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2167}
2168
2169static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2170 struct btrfs_balance_item *bi,
2171 struct btrfs_disk_balance_args *ba)
2172{
2173 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2174}
2175
2176static inline void btrfs_balance_meta(struct extent_buffer *eb,
2177 struct btrfs_balance_item *bi,
2178 struct btrfs_disk_balance_args *ba)
2179{
2180 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2181}
2182
2183static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2184 struct btrfs_balance_item *bi,
2185 struct btrfs_disk_balance_args *ba)
2186{
2187 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2188}
2189
2190static inline void btrfs_balance_sys(struct extent_buffer *eb,
2191 struct btrfs_balance_item *bi,
2192 struct btrfs_disk_balance_args *ba)
2193{
2194 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2195}
2196
2197static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2198 struct btrfs_balance_item *bi,
2199 struct btrfs_disk_balance_args *ba)
2200{
2201 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2202}
2203
2204static inline void
2205btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2206 struct btrfs_disk_balance_args *disk)
2207{
2208 memset(cpu, 0, sizeof(*cpu));
2209
2210 cpu->profiles = le64_to_cpu(disk->profiles);
2211 cpu->usage = le64_to_cpu(disk->usage);
2212 cpu->devid = le64_to_cpu(disk->devid);
2213 cpu->pstart = le64_to_cpu(disk->pstart);
2214 cpu->pend = le64_to_cpu(disk->pend);
2215 cpu->vstart = le64_to_cpu(disk->vstart);
2216 cpu->vend = le64_to_cpu(disk->vend);
2217 cpu->target = le64_to_cpu(disk->target);
2218 cpu->flags = le64_to_cpu(disk->flags);
David Sterba7d824b62014-05-07 17:37:51 +02002219 cpu->limit = le64_to_cpu(disk->limit);
David Sterbaed0df612016-11-01 14:21:23 +01002220 cpu->stripes_min = le32_to_cpu(disk->stripes_min);
2221 cpu->stripes_max = le32_to_cpu(disk->stripes_max);
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002222}
2223
2224static inline void
2225btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2226 struct btrfs_balance_args *cpu)
2227{
2228 memset(disk, 0, sizeof(*disk));
2229
2230 disk->profiles = cpu_to_le64(cpu->profiles);
2231 disk->usage = cpu_to_le64(cpu->usage);
2232 disk->devid = cpu_to_le64(cpu->devid);
2233 disk->pstart = cpu_to_le64(cpu->pstart);
2234 disk->pend = cpu_to_le64(cpu->pend);
2235 disk->vstart = cpu_to_le64(cpu->vstart);
2236 disk->vend = cpu_to_le64(cpu->vend);
2237 disk->target = cpu_to_le64(cpu->target);
2238 disk->flags = cpu_to_le64(cpu->flags);
David Sterba7d824b62014-05-07 17:37:51 +02002239 disk->limit = cpu_to_le64(cpu->limit);
David Sterbaed0df612016-11-01 14:21:23 +01002240 disk->stripes_min = cpu_to_le32(cpu->stripes_min);
2241 disk->stripes_max = cpu_to_le32(cpu->stripes_max);
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002242}
2243
2244/* struct btrfs_super_block */
Chris Masondb945352007-10-15 16:15:53 -04002245BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
Chris Masona061fc82008-05-07 11:43:44 -04002246BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002247BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2248 generation, 64);
2249BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002250BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2251 struct btrfs_super_block, sys_chunk_array_size, 32);
Yan Zheng84234f32008-10-29 14:49:05 -04002252BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2253 struct btrfs_super_block, chunk_root_generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002254BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2255 root_level, 8);
Chris Mason0b86a832008-03-24 15:01:56 -04002256BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2257 chunk_root, 64);
2258BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
Chris Masone02119d2008-09-05 16:13:11 -04002259 chunk_root_level, 8);
2260BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2261 log_root, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05002262BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2263 log_root_transid, 64);
Chris Masone02119d2008-09-05 16:13:11 -04002264BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2265 log_root_level, 8);
Chris Masondb945352007-10-15 16:15:53 -04002266BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2267 total_bytes, 64);
2268BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2269 bytes_used, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002270BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2271 sectorsize, 32);
2272BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2273 nodesize, 32);
Chris Mason87ee04e2007-11-30 11:30:34 -05002274BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2275 stripesize, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002276BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2277 root_dir_objectid, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04002278BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2279 num_devices, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002280BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2281 compat_flags, 64);
2282BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
Josef Bacik12534832009-12-17 21:32:27 +00002283 compat_ro_flags, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002284BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2285 incompat_flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002286BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2287 csum_type, 16);
Josef Bacik0af3d002010-06-21 14:48:16 -04002288BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2289 cache_generation, 64);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002290BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
Stefan Behrens26432792013-08-15 17:11:22 +02002291BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2292 uuid_tree_generation, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002293
2294static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
2295{
David Sterba1104a882013-03-06 15:57:46 +01002296 u16 t = btrfs_super_csum_type(s);
2297 /*
2298 * csum type is validated at mount time
2299 */
Josef Bacik607d4322008-12-02 07:17:45 -05002300 return btrfs_csum_sizes[t];
2301}
Chris Mason5f39d392007-10-15 16:14:19 -04002302
2303static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
Chris Mason7f5c1512007-03-23 15:56:19 -04002304{
Chris Mason5f39d392007-10-15 16:14:19 -04002305 return offsetof(struct btrfs_leaf, items);
Chris Mason7f5c1512007-03-23 15:56:19 -04002306}
2307
Liu Bo851cd172016-09-23 13:44:44 -07002308/*
2309 * The leaf data grows from end-to-front in the node.
2310 * this returns the address of the start of the last item,
2311 * which is the stop of the leaf data stack
2312 */
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002313static inline unsigned int leaf_data_end(struct btrfs_fs_info *fs_info,
Liu Bo851cd172016-09-23 13:44:44 -07002314 struct extent_buffer *leaf)
2315{
2316 u32 nr = btrfs_header_nritems(leaf);
2317
2318 if (nr == 0)
Jeff Mahoney0b246af2016-06-22 18:54:23 -04002319 return BTRFS_LEAF_DATA_SIZE(fs_info);
Liu Bo851cd172016-09-23 13:44:44 -07002320 return btrfs_item_offset_nr(leaf, nr - 1);
2321}
2322
Chris Mason5f39d392007-10-15 16:14:19 -04002323/* struct btrfs_file_extent_item */
2324BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
Qu Wenruo3cae2102013-07-16 11:19:18 +08002325BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2326 struct btrfs_file_extent_item, disk_bytenr, 64);
2327BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
2328 struct btrfs_file_extent_item, offset, 64);
2329BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
2330 struct btrfs_file_extent_item, generation, 64);
2331BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2332 struct btrfs_file_extent_item, num_bytes, 64);
Josef Bacike20d6c52013-11-13 21:11:49 -05002333BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2334 struct btrfs_file_extent_item, disk_num_bytes, 64);
2335BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
2336 struct btrfs_file_extent_item, compression, 8);
Chris Mason7f5c1512007-03-23 15:56:19 -04002337
Chris Masond3977122009-01-05 21:25:51 -05002338static inline unsigned long
2339btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
Chris Mason236454d2007-04-19 13:37:44 -04002340{
David Sterba7ec20af2014-07-24 17:34:58 +02002341 return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
Chris Mason236454d2007-04-19 13:37:44 -04002342}
2343
2344static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2345{
David Sterba7ec20af2014-07-24 17:34:58 +02002346 return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
Chris Mason236454d2007-04-19 13:37:44 -04002347}
2348
Chris Masondb945352007-10-15 16:15:53 -04002349BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2350 disk_bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002351BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2352 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002353BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2354 disk_num_bytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002355BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2356 offset, 64);
Chris Masondb945352007-10-15 16:15:53 -04002357BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2358 num_bytes, 64);
Chris Masonc8b97812008-10-29 14:49:59 -04002359BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2360 ram_bytes, 64);
2361BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2362 compression, 8);
2363BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2364 encryption, 8);
2365BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2366 other_encoding, 16);
2367
Chris Masonc8b97812008-10-29 14:49:59 -04002368/*
2369 * this returns the number of bytes used by the item on disk, minus the
2370 * size of any extent headers. If a file is compressed on disk, this is
2371 * the compressed size
2372 */
2373static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
2374 struct btrfs_item *e)
2375{
David Sterba7ec20af2014-07-24 17:34:58 +02002376 return btrfs_item_size(eb, e) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
Chris Masonc8b97812008-10-29 14:49:59 -04002377}
Chris Mason9f5fae22007-03-20 14:38:32 -04002378
Chris Mason514ac8a2014-01-03 21:07:00 -08002379/* this returns the number of file bytes represented by the inline item.
2380 * If an item is compressed, this is the uncompressed size
2381 */
2382static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
2383 int slot,
2384 struct btrfs_file_extent_item *fi)
2385{
2386 struct btrfs_map_token token;
2387
2388 btrfs_init_map_token(&token);
2389 /*
2390 * return the space used on disk if this item isn't
2391 * compressed or encoded
2392 */
2393 if (btrfs_token_file_extent_compression(eb, fi, &token) == 0 &&
2394 btrfs_token_file_extent_encryption(eb, fi, &token) == 0 &&
2395 btrfs_token_file_extent_other_encoding(eb, fi, &token) == 0) {
2396 return btrfs_file_extent_inline_item_len(eb,
2397 btrfs_item_nr(slot));
2398 }
2399
2400 /* otherwise use the ram bytes field */
2401 return btrfs_token_file_extent_ram_bytes(eb, fi, &token);
2402}
2403
2404
Stefan Behrens733f4fb2012-05-25 16:06:10 +02002405/* btrfs_dev_stats_item */
2406static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb,
2407 struct btrfs_dev_stats_item *ptr,
2408 int index)
2409{
2410 u64 val;
2411
2412 read_extent_buffer(eb, &val,
2413 offsetof(struct btrfs_dev_stats_item, values) +
2414 ((unsigned long)ptr) + (index * sizeof(u64)),
2415 sizeof(val));
2416 return val;
2417}
2418
2419static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
2420 struct btrfs_dev_stats_item *ptr,
2421 int index, u64 val)
2422{
2423 write_extent_buffer(eb, &val,
2424 offsetof(struct btrfs_dev_stats_item, values) +
2425 ((unsigned long)ptr) + (index * sizeof(u64)),
2426 sizeof(val));
2427}
2428
Arne Jansen630dc772011-09-13 11:06:07 +02002429/* btrfs_qgroup_status_item */
2430BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2431 generation, 64);
2432BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2433 version, 64);
2434BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2435 flags, 64);
Jan Schmidt2f232032013-04-25 16:04:51 +00002436BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
2437 rescan, 64);
Arne Jansen630dc772011-09-13 11:06:07 +02002438
2439/* btrfs_qgroup_info_item */
2440BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2441 generation, 64);
2442BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2443BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2444 rfer_cmpr, 64);
2445BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2446BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2447 excl_cmpr, 64);
2448
2449BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2450 struct btrfs_qgroup_info_item, generation, 64);
2451BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2452 rfer, 64);
2453BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2454 struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2455BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2456 excl, 64);
2457BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2458 struct btrfs_qgroup_info_item, excl_cmpr, 64);
2459
2460/* btrfs_qgroup_limit_item */
2461BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2462 flags, 64);
2463BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2464 max_rfer, 64);
2465BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2466 max_excl, 64);
2467BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2468 rsv_rfer, 64);
2469BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2470 rsv_excl, 64);
2471
Stefan Behrensa2bff642012-11-05 17:32:20 +01002472/* btrfs_dev_replace_item */
2473BTRFS_SETGET_FUNCS(dev_replace_src_devid,
2474 struct btrfs_dev_replace_item, src_devid, 64);
2475BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
2476 struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
2477 64);
2478BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
2479 replace_state, 64);
2480BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
2481 time_started, 64);
2482BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
2483 time_stopped, 64);
2484BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
2485 num_write_errors, 64);
2486BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
2487 struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
2488 64);
2489BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
2490 cursor_left, 64);
2491BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
2492 cursor_right, 64);
2493
2494BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
2495 struct btrfs_dev_replace_item, src_devid, 64);
2496BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
2497 struct btrfs_dev_replace_item,
2498 cont_reading_from_srcdev_mode, 64);
2499BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
2500 struct btrfs_dev_replace_item, replace_state, 64);
2501BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
2502 struct btrfs_dev_replace_item, time_started, 64);
2503BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
2504 struct btrfs_dev_replace_item, time_stopped, 64);
2505BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
2506 struct btrfs_dev_replace_item, num_write_errors, 64);
2507BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
2508 struct btrfs_dev_replace_item,
2509 num_uncorrectable_read_errors, 64);
2510BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
2511 struct btrfs_dev_replace_item, cursor_left, 64);
2512BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
2513 struct btrfs_dev_replace_item, cursor_right, 64);
2514
Chris Mason4beb1b82007-03-14 10:31:29 -04002515/* helper function to cast into the data area of the leaf. */
2516#define btrfs_item_ptr(leaf, slot, type) \
Chris Mason123abc82007-03-14 14:14:43 -04002517 ((type *)(btrfs_leaf_data(leaf) + \
Chris Mason5f39d392007-10-15 16:14:19 -04002518 btrfs_item_offset_nr(leaf, slot)))
2519
2520#define btrfs_item_ptr_offset(leaf, slot) \
2521 ((unsigned long)(btrfs_leaf_data(leaf) + \
2522 btrfs_item_offset_nr(leaf, slot)))
Chris Mason4beb1b82007-03-14 10:31:29 -04002523
Josef Bacik67377732010-09-16 16:19:09 -04002524static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
2525{
2526 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
2527 (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
2528}
2529
Josef Bacik3b16a4e2011-09-21 15:05:58 -04002530static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2531{
Michal Hockoc62d2552015-11-06 16:28:49 -08002532 return mapping_gfp_constraint(mapping, ~__GFP_FS);
Josef Bacik3b16a4e2011-09-21 15:05:58 -04002533}
2534
Chris Masonb18c6682007-04-17 13:26:50 -04002535/* extent-tree.c */
Chris Mason28f75a02015-02-04 06:59:29 -08002536
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002537u64 btrfs_csum_bytes_to_leaves(struct btrfs_fs_info *fs_info, u64 csum_bytes);
Chris Mason28f75a02015-02-04 06:59:29 -08002538
Jeff Mahoney27965b62016-06-16 11:07:27 -04002539static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_fs_info *fs_info,
Josef Bacik9e0baf62011-07-15 15:16:44 +00002540 unsigned num_items)
Miao Xie16cdcec2011-04-22 18:12:22 +08002541{
Jeff Mahoney27965b62016-06-16 11:07:27 -04002542 return fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
Miao Xie16cdcec2011-04-22 18:12:22 +08002543}
2544
Josef Bacik07127182011-08-19 10:29:59 -04002545/*
2546 * Doing a truncate won't result in new nodes or leaves, just what we need for
2547 * COW.
2548 */
Jeff Mahoney27965b62016-06-16 11:07:27 -04002549static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_fs_info *fs_info,
Josef Bacik07127182011-08-19 10:29:59 -04002550 unsigned num_items)
2551{
Jeff Mahoney27965b62016-06-16 11:07:27 -04002552 return fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
Josef Bacik07127182011-08-19 10:29:59 -04002553}
2554
Josef Bacik1be41b72013-06-12 13:56:06 -04002555int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002556 struct btrfs_fs_info *fs_info);
Josef Bacik0a2b2a82014-01-23 10:54:11 -05002557int btrfs_check_space_for_delayed_refs(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002558 struct btrfs_fs_info *fs_info);
Filipe Manana9cfa3e32016-04-26 15:39:32 +01002559void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
2560 const u64 start);
2561void btrfs_wait_block_group_reservations(struct btrfs_block_group_cache *bg);
Filipe Mananaf78c4362016-05-09 13:15:41 +01002562bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2563void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr);
2564void btrfs_wait_nocow_writers(struct btrfs_block_group_cache *bg);
Chris Masonfa9c0d792009-04-03 09:47:43 -04002565void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Chris Mason56bec292009-03-13 10:10:06 -04002566int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002567 struct btrfs_fs_info *fs_info, unsigned long count);
2568int btrfs_async_run_delayed_refs(struct btrfs_fs_info *fs_info,
Josef Bacik31b96552016-04-11 17:37:40 -04002569 unsigned long count, u64 transid, int wait);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002570int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002571int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002572 struct btrfs_fs_info *fs_info, u64 bytenr,
Josef Bacik3173a182013-03-07 14:22:04 -05002573 u64 offset, int metadata, u64 *refs, u64 *flags);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002574int btrfs_pin_extent(struct btrfs_fs_info *fs_info,
Yan Zheng11833d62009-09-11 16:11:19 -04002575 u64 bytenr, u64 num, int reserved);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002576int btrfs_pin_extent_for_log_replay(struct btrfs_fs_info *fs_info,
Chris Masone688b7252011-10-31 20:52:39 -04002577 u64 bytenr, u64 num_bytes);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002578int btrfs_exclude_logged_extents(struct btrfs_fs_info *fs_info,
Josef Bacik8c2a1a32013-06-06 13:19:32 -04002579 struct extent_buffer *eb);
Yan Zheng80ff3852008-10-30 14:20:02 -04002580int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002581 struct btrfs_root *root,
2582 u64 objectid, u64 offset, u64 bytenr);
Chris Masond3977122009-01-05 21:25:51 -05002583struct btrfs_block_group_cache *btrfs_lookup_block_group(
2584 struct btrfs_fs_info *info,
2585 u64 bytenr);
Filipe Manana758f2df2015-11-19 11:45:48 +00002586void btrfs_get_block_group(struct btrfs_block_group_cache *cache);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002587void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Jeff Mahoney6ab0a202013-11-01 13:07:04 -04002588int get_block_group_index(struct btrfs_block_group_cache *cache);
David Sterba4d75f8a2014-06-15 01:54:12 +02002589struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
2590 struct btrfs_root *root, u64 parent,
2591 u64 root_objectid,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002592 struct btrfs_disk_key *key, int level,
Jan Schmidt5581a512012-05-16 17:04:52 +02002593 u64 hint, u64 empty_size);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002594void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2595 struct btrfs_root *root,
2596 struct extent_buffer *buf,
Jan Schmidt5581a512012-05-16 17:04:52 +02002597 u64 parent, int last_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002598int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002599 u64 root_objectid, u64 owner,
Qu Wenruo5846a3c2015-10-26 14:11:18 +08002600 u64 offset, u64 ram_bytes,
2601 struct btrfs_key *ins);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002602int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002603 struct btrfs_fs_info *fs_info,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002604 u64 root_objectid, u64 owner, u64 offset,
2605 struct btrfs_key *ins);
Wang Xiaoguang18513092016-07-25 15:51:40 +08002606int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes, u64 num_bytes,
Josef Bacik00361582013-08-14 14:02:47 -04002607 u64 min_alloc_size, u64 empty_size, u64 hint_byte,
Miao Xiee570fd22014-06-19 10:42:50 +08002608 struct btrfs_key *ins, int is_data, int delalloc);
Chris Masone089f052007-03-16 16:20:31 -04002609int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Josef Bacike339a6b2014-07-02 10:54:25 -07002610 struct extent_buffer *buf, int full_backref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002611int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Josef Bacike339a6b2014-07-02 10:54:25 -07002612 struct extent_buffer *buf, int full_backref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002613int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002614 struct btrfs_fs_info *fs_info,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002615 u64 bytenr, u64 num_bytes, u64 flags,
Josef Bacikb1c79e02013-05-09 13:49:30 -04002616 int level, int is_data);
Zheng Yan31840ae2008-09-23 13:14:14 -04002617int btrfs_free_extent(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002618 struct btrfs_fs_info *fs_info,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002619 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01002620 u64 owner, u64 offset);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002621
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002622int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2623 u64 start, u64 len, int delalloc);
2624int btrfs_free_and_pin_reserved_extent(struct btrfs_fs_info *fs_info,
Chris Masone688b7252011-10-31 20:52:39 -04002625 u64 start, u64 len);
Jeff Mahoney143bede2012-03-01 14:56:26 +01002626void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002627 struct btrfs_fs_info *fs_info);
Chris Masonccd467d2007-06-28 15:57:36 -04002628int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002629 struct btrfs_fs_info *fs_info);
Chris Masonb18c6682007-04-17 13:26:50 -04002630int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002631 struct btrfs_fs_info *fs_info,
Zheng Yan31840ae2008-09-23 13:14:14 -04002632 u64 bytenr, u64 num_bytes, u64 parent,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01002633 u64 root_objectid, u64 owner, u64 offset);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002634
Chris Mason1bbc6212015-04-06 12:46:08 -07002635int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002636 struct btrfs_fs_info *fs_info);
Chris Mason9078a3e2007-04-26 16:46:15 -04002637int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002638 struct btrfs_fs_info *fs_info);
Josef Bacikdcdf7f62015-03-02 16:37:31 -05002639int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002640 struct btrfs_fs_info *fs_info);
2641int btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr);
Chris Mason9078a3e2007-04-26 16:46:15 -04002642int btrfs_free_block_groups(struct btrfs_fs_info *info);
Jeff Mahoney5b4aace2016-06-21 10:40:19 -04002643int btrfs_read_block_groups(struct btrfs_fs_info *info);
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002644int btrfs_can_relocate(struct btrfs_fs_info *fs_info, u64 bytenr);
Chris Mason0b86a832008-03-24 15:01:56 -04002645int btrfs_make_block_group(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002646 struct btrfs_fs_info *fs_info, u64 bytes_used,
Chris Masone17cade2008-04-15 15:41:47 -04002647 u64 type, u64 chunk_objectid, u64 chunk_offset,
Chris Mason0b86a832008-03-24 15:01:56 -04002648 u64 size);
Filipe Manana8eab77f2015-11-13 23:57:16 +00002649struct btrfs_trans_handle *btrfs_start_trans_remove_block_group(
Filipe Manana7fd01182015-11-13 23:57:17 +00002650 struct btrfs_fs_info *fs_info,
2651 const u64 chunk_offset);
Zheng Yan1a40e232008-09-26 10:09:34 -04002652int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002653 struct btrfs_fs_info *fs_info, u64 group_start,
Filipe Manana04216822014-11-27 21:14:15 +00002654 struct extent_map *em);
Josef Bacik47ab2a62014-09-18 11:20:02 -04002655void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info);
Jeff Mahoneye33e17e2015-06-15 09:41:19 -04002656void btrfs_get_block_group_trimming(struct btrfs_block_group_cache *cache);
2657void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *cache);
Josef Bacikea658ba2012-09-11 16:57:25 -04002658void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002659 struct btrfs_fs_info *fs_info);
Miao Xie6d07bce2011-01-05 10:07:31 +00002660u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
Chris Mason4184ea72009-03-10 12:39:20 -04002661void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
Miao Xie08e007d2012-10-16 11:33:38 +00002662
2663enum btrfs_reserve_flush_enum {
2664 /* If we are in the transaction, we can't flush anything.*/
2665 BTRFS_RESERVE_NO_FLUSH,
2666 /*
2667 * Flushing delalloc may cause deadlock somewhere, in this
2668 * case, use FLUSH LIMIT
2669 */
2670 BTRFS_RESERVE_FLUSH_LIMIT,
2671 BTRFS_RESERVE_FLUSH_ALL,
2672};
2673
Josef Bacikf376df22016-03-25 13:25:56 -04002674enum btrfs_flush_state {
2675 FLUSH_DELAYED_ITEMS_NR = 1,
2676 FLUSH_DELAYED_ITEMS = 2,
2677 FLUSH_DELALLOC = 3,
2678 FLUSH_DELALLOC_WAIT = 4,
2679 ALLOC_CHUNK = 5,
2680 COMMIT_TRANS = 6,
2681};
2682
Qu Wenruo7cf5b972015-09-08 17:25:55 +08002683int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);
Qu Wenruo4ceff072015-09-08 17:22:42 +08002684int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes);
Qu Wenruo7cf5b972015-09-08 17:25:55 +08002685void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);
Qu Wenruo51773be2015-10-08 18:19:37 +08002686void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start,
2687 u64 len);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002688void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002689 struct btrfs_fs_info *fs_info);
Filipe Manana4fbcdf62015-05-20 14:01:54 +01002690void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
Yan, Zhengd68fc572010-05-16 10:49:58 -04002691int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
2692 struct inode *inode);
2693void btrfs_orphan_release_metadata(struct inode *inode);
Miao Xied5c12072013-02-28 10:04:33 +00002694int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2695 struct btrfs_block_rsv *rsv,
2696 int nitems,
Jeff Mahoneyee3441b2013-07-09 16:37:21 -04002697 u64 *qgroup_reserved, bool use_global_rsv);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002698void btrfs_subvolume_release_metadata(struct btrfs_fs_info *fs_info,
Miao Xied5c12072013-02-28 10:04:33 +00002699 struct btrfs_block_rsv *rsv,
2700 u64 qgroup_reserved);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002701int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
2702void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
Qu Wenruo7cf5b972015-09-08 17:25:55 +08002703int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);
2704void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);
Miao Xie66d8f3d2012-09-06 04:02:28 -06002705void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002706struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
Miao Xie66d8f3d2012-09-06 04:02:28 -06002707 unsigned short type);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002708void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002709 struct btrfs_block_rsv *rsv);
Chris Masoncdfb0802015-04-06 18:17:00 -07002710void __btrfs_free_block_rsv(struct btrfs_block_rsv *rsv);
Josef Bacik4a92b1b2011-08-30 12:34:28 -04002711int btrfs_block_rsv_add(struct btrfs_root *root,
Miao Xie08e007d2012-10-16 11:33:38 +00002712 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
2713 enum btrfs_reserve_flush_enum flush);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002714int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor);
Josef Bacik36ba0222011-10-18 12:15:48 -04002715int btrfs_block_rsv_refill(struct btrfs_root *root,
Miao Xie08e007d2012-10-16 11:33:38 +00002716 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
2717 enum btrfs_reserve_flush_enum flush);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002718int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
Josef Bacik25d609f2016-03-25 13:25:48 -04002719 struct btrfs_block_rsv *dst_rsv, u64 num_bytes,
2720 int update_size);
Josef Bacikd52be812013-05-29 14:54:47 -04002721int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
2722 struct btrfs_block_rsv *dest, u64 num_bytes,
2723 int min_factor);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002724void btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002725 struct btrfs_block_rsv *block_rsv,
2726 u64 num_bytes);
Zhaolei868f4012015-08-05 16:43:27 +08002727int btrfs_inc_block_group_ro(struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002728 struct btrfs_block_group_cache *cache);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002729void btrfs_dec_block_group_ro(struct btrfs_block_group_cache *cache);
Josef Bacik0af3d002010-06-21 14:48:16 -04002730void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
Miao Xie6d07bce2011-01-05 10:07:31 +00002731u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002732int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
liuboacce9522011-01-06 19:30:25 +08002733 u64 start, u64 end);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002734int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
Filipe Manana1edb647b2014-12-08 14:01:12 +00002735 u64 num_bytes, u64 *actual_bytes);
Chris Masonc87f08c2011-02-16 13:57:04 -05002736int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002737 struct btrfs_fs_info *fs_info, u64 type);
2738int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
liuboacce9522011-01-06 19:30:25 +08002739
liuboc59021f2011-03-07 02:13:14 +00002740int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
Arne Jansenbed92ea2012-06-28 18:03:02 +02002741int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2742 struct btrfs_fs_info *fs_info);
Liu Bo31e50222012-11-21 14:18:10 +00002743int __get_raid_index(u64 flags);
Filipe Manana9ea24bb2014-10-29 11:57:59 +00002744int btrfs_start_write_no_snapshoting(struct btrfs_root *root);
2745void btrfs_end_write_no_snapshoting(struct btrfs_root *root);
Zhao Lei0bc19f902016-01-06 18:56:36 +08002746void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
Filipe Manana39c2d7f2015-05-20 14:01:55 +01002747void check_system_chunk(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002748 struct btrfs_fs_info *fs_info, const u64 type);
Omar Sandovala5ed9182015-09-29 20:50:35 -07002749u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
2750 struct btrfs_fs_info *info, u64 start, u64 end);
2751
Chris Masondee26a92007-03-26 16:00:06 -04002752/* ctree.c */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002753int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
2754 int level, int *slot);
2755int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
Chris Mason0b86a832008-03-24 15:01:56 -04002756int btrfs_previous_item(struct btrfs_root *root,
2757 struct btrfs_path *path, u64 min_objectid,
2758 int type);
Wang Shilongade2e0b2014-01-12 21:38:33 +08002759int btrfs_previous_extent_item(struct btrfs_root *root,
2760 struct btrfs_path *path, u64 min_objectid);
Daniel Dresslerb7a03652014-11-12 13:43:09 +09002761void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
2762 struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01002763 struct btrfs_key *new_key);
Chris Mason925baed2008-06-25 16:01:30 -04002764struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2765struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
Chris Masone7a84562008-06-25 16:01:31 -04002766int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
Chris Mason3f157a22008-06-25 16:01:31 -04002767 struct btrfs_key *key, int lowest_level,
Eric Sandeende78b512013-01-31 18:21:12 +00002768 u64 min_trans);
Chris Mason3f157a22008-06-25 16:01:31 -04002769int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
Eric Sandeende78b512013-01-31 18:21:12 +00002770 struct btrfs_path *path,
Chris Mason3f157a22008-06-25 16:01:31 -04002771 u64 min_trans);
Alexander Block70698302012-06-05 21:07:48 +02002772enum btrfs_compare_tree_result {
2773 BTRFS_COMPARE_TREE_NEW,
2774 BTRFS_COMPARE_TREE_DELETED,
2775 BTRFS_COMPARE_TREE_CHANGED,
Josef Bacikba5e8f22013-08-16 16:52:55 -04002776 BTRFS_COMPARE_TREE_SAME,
Alexander Block70698302012-06-05 21:07:48 +02002777};
2778typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root,
2779 struct btrfs_root *right_root,
2780 struct btrfs_path *left_path,
2781 struct btrfs_path *right_path,
2782 struct btrfs_key *key,
2783 enum btrfs_compare_tree_result result,
2784 void *ctx);
2785int btrfs_compare_trees(struct btrfs_root *left_root,
2786 struct btrfs_root *right_root,
2787 btrfs_changed_cb_t cb, void *ctx);
Chris Mason5f39d392007-10-15 16:14:19 -04002788int btrfs_cow_block(struct btrfs_trans_handle *trans,
2789 struct btrfs_root *root, struct extent_buffer *buf,
2790 struct extent_buffer *parent, int parent_slot,
Chris Mason9fa8cfe2009-03-13 10:24:59 -04002791 struct extent_buffer **cow_ret);
Chris Masonbe20aa92007-12-17 20:14:01 -05002792int btrfs_copy_root(struct btrfs_trans_handle *trans,
2793 struct btrfs_root *root,
2794 struct extent_buffer *buf,
2795 struct extent_buffer **cow_ret, u64 new_root_objectid);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002796int btrfs_block_can_be_shared(struct btrfs_root *root,
2797 struct extent_buffer *buf);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002798void btrfs_extend_item(struct btrfs_fs_info *fs_info, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01002799 u32 data_size);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002800void btrfs_truncate_item(struct btrfs_fs_info *fs_info,
2801 struct btrfs_path *path, u32 new_size, int from_end);
Chris Mason459931e2008-12-10 09:10:46 -05002802int btrfs_split_item(struct btrfs_trans_handle *trans,
2803 struct btrfs_root *root,
2804 struct btrfs_path *path,
2805 struct btrfs_key *new_key,
2806 unsigned long split_offset);
Yan, Zhengad48fd752009-11-12 09:33:58 +00002807int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2808 struct btrfs_root *root,
2809 struct btrfs_path *path,
2810 struct btrfs_key *new_key);
Kelley Nielsene33d5c32013-11-04 19:33:33 -08002811int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
2812 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
Chris Masone089f052007-03-16 16:20:31 -04002813int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
2814 *root, struct btrfs_key *key, struct btrfs_path *p, int
2815 ins_len, int cow);
Jan Schmidt5d9e75c42012-05-16 18:25:47 +02002816int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
2817 struct btrfs_path *p, u64 time_seq);
Arne Jansen2f38b3e2011-09-13 11:18:10 +02002818int btrfs_search_slot_for_read(struct btrfs_root *root,
2819 struct btrfs_key *key, struct btrfs_path *p,
2820 int find_higher, int return_any);
Chris Mason6702ed42007-08-07 16:15:09 -04002821int btrfs_realloc_node(struct btrfs_trans_handle *trans,
Chris Mason5f39d392007-10-15 16:14:19 -04002822 struct btrfs_root *root, struct extent_buffer *parent,
Eric Sandeende78b512013-01-31 18:21:12 +00002823 int start_slot, u64 *last_ret,
Chris Masona6b6e752007-10-15 16:22:39 -04002824 struct btrfs_key *progress);
David Sterbab3b4aa72011-04-21 01:20:15 +02002825void btrfs_release_path(struct btrfs_path *p);
Chris Mason2c90e5d2007-04-02 10:50:19 -04002826struct btrfs_path *btrfs_alloc_path(void);
2827void btrfs_free_path(struct btrfs_path *p);
Chris Masonb4ce94d2009-02-04 09:25:08 -05002828void btrfs_set_path_blocking(struct btrfs_path *p);
Miao Xie16cdcec2011-04-22 18:12:22 +08002829void btrfs_clear_path_blocking(struct btrfs_path *p,
Chris Masonbd681512011-07-16 15:23:14 -04002830 struct extent_buffer *held, int held_rw);
Chris Masonb4ce94d2009-02-04 09:25:08 -05002831void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2832
Chris Mason85e21ba2008-01-29 15:11:36 -05002833int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2834 struct btrfs_path *path, int slot, int nr);
Chris Mason85e21ba2008-01-29 15:11:36 -05002835static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2836 struct btrfs_root *root,
2837 struct btrfs_path *path)
2838{
2839 return btrfs_del_items(trans, root, path, path->slots[0], 1);
2840}
2841
Tsutomu Itohafe5fea2013-04-16 05:18:22 +00002842void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
Jeff Mahoney143bede2012-03-01 14:56:26 +01002843 struct btrfs_key *cpu_key, u32 *data_size,
2844 u32 total_data, u32 total_size, int nr);
Chris Masone089f052007-03-16 16:20:31 -04002845int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
2846 *root, struct btrfs_key *key, void *data, u32 data_size);
Chris Mason9c583092008-01-29 15:15:18 -05002847int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
2848 struct btrfs_root *root,
2849 struct btrfs_path *path,
2850 struct btrfs_key *cpu_key, u32 *data_size, int nr);
2851
2852static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
2853 struct btrfs_root *root,
2854 struct btrfs_path *path,
2855 struct btrfs_key *key,
2856 u32 data_size)
2857{
2858 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
2859}
2860
Chris Mason234b63a2007-03-13 10:46:10 -04002861int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
Josef Bacik16e75492013-10-22 12:18:51 -04002862int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
Jan Schmidt3d7806e2012-06-11 08:29:29 +02002863int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
2864 u64 time_seq);
Alexander Block1c8f52a2012-06-19 07:42:25 -06002865static inline int btrfs_next_old_item(struct btrfs_root *root,
2866 struct btrfs_path *p, u64 time_seq)
Jan Schmidtc7d22a32011-11-22 15:14:33 +01002867{
2868 ++p->slots[0];
2869 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
Alexander Block1c8f52a2012-06-19 07:42:25 -06002870 return btrfs_next_old_leaf(root, p, time_seq);
Jan Schmidtc7d22a32011-11-22 15:14:33 +01002871 return 0;
2872}
Alexander Block1c8f52a2012-06-19 07:42:25 -06002873static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
2874{
2875 return btrfs_next_old_item(root, p, 0);
2876}
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002877int btrfs_leaf_free_space(struct btrfs_fs_info *fs_info,
2878 struct extent_buffer *leaf);
Jeff Mahoney2c536792011-10-03 23:22:41 -04002879int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
2880 struct btrfs_block_rsv *block_rsv,
2881 int update_ref, int for_reloc);
Yan Zhengf82d02d2008-10-29 14:49:05 -04002882int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2883 struct btrfs_root *root,
2884 struct extent_buffer *node,
2885 struct extent_buffer *parent);
David Sterba7841cb22011-05-31 18:07:27 +02002886static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
2887{
2888 /*
Josef Bacikafcdd122016-09-02 15:40:02 -04002889 * Do it this way so we only ever do one test_bit in the normal case.
David Sterba7841cb22011-05-31 18:07:27 +02002890 */
Josef Bacikafcdd122016-09-02 15:40:02 -04002891 if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
2892 if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
2893 return 2;
2894 return 1;
2895 }
2896 return 0;
David Sterba7841cb22011-05-31 18:07:27 +02002897}
Miao Xiebabbf1702013-05-14 10:20:43 +00002898
2899/*
2900 * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
2901 * anything except sleeping. This function is used to check the status of
2902 * the fs.
2903 */
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002904static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
Miao Xiebabbf1702013-05-14 10:20:43 +00002905{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04002906 return fs_info->sb->s_flags & MS_RDONLY || btrfs_fs_closing(fs_info);
Miao Xiebabbf1702013-05-14 10:20:43 +00002907}
2908
David Sterba6c417612011-04-13 15:41:04 +02002909static inline void free_fs_info(struct btrfs_fs_info *fs_info)
2910{
Ilya Dryomov837d5b62012-01-16 22:04:49 +02002911 kfree(fs_info->balance_ctl);
David Sterba6c417612011-04-13 15:41:04 +02002912 kfree(fs_info->delayed_root);
2913 kfree(fs_info->extent_root);
2914 kfree(fs_info->tree_root);
2915 kfree(fs_info->chunk_root);
2916 kfree(fs_info->dev_root);
2917 kfree(fs_info->csum_root);
Arne Jansenbcef60f2011-09-13 15:23:30 +02002918 kfree(fs_info->quota_root);
Filipe David Borba Mananad8f98032013-08-24 19:51:06 +01002919 kfree(fs_info->uuid_root);
Omar Sandoval70f6d822015-09-29 20:50:38 -07002920 kfree(fs_info->free_space_root);
David Sterba6c417612011-04-13 15:41:04 +02002921 kfree(fs_info->super_copy);
2922 kfree(fs_info->super_for_commit);
Qu Wenruof667aef2014-09-23 13:40:08 +08002923 security_free_mnt_opts(&fs_info->security_opts);
David Sterba6c417612011-04-13 15:41:04 +02002924 kfree(fs_info);
2925}
David Sterba7841cb22011-05-31 18:07:27 +02002926
Jan Schmidt097b8a72012-06-21 11:08:04 +02002927/* tree mod log functions from ctree.c */
2928u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
2929 struct seq_list *elem);
2930void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
2931 struct seq_list *elem);
Jan Schmidt5b6602e2012-10-23 11:28:27 +02002932int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
Jan Schmidt097b8a72012-06-21 11:08:04 +02002933
Chris Masondee26a92007-03-26 16:00:06 -04002934/* root-item.c */
Chris Mason0660b5a2008-11-17 20:37:39 -05002935int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002936 struct btrfs_fs_info *fs_info,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002937 u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
2938 const char *name, int name_len);
2939int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002940 struct btrfs_fs_info *fs_info,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002941 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
Chris Mason0660b5a2008-11-17 20:37:39 -05002942 const char *name, int name_len);
Chris Masone089f052007-03-16 16:20:31 -04002943int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2944 struct btrfs_key *key);
2945int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
2946 *root, struct btrfs_key *key, struct btrfs_root_item
2947 *item);
Jeff Mahoneyb45a9d82011-10-03 23:22:44 -04002948int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
2949 struct btrfs_root *root,
2950 struct btrfs_key *key,
2951 struct btrfs_root_item *item);
Miao Xiecb517ea2013-05-15 07:48:19 +00002952int btrfs_find_root(struct btrfs_root *root, struct btrfs_key *search_key,
2953 struct btrfs_path *path, struct btrfs_root_item *root_item,
2954 struct btrfs_key *root_key);
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002955int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);
Mark Fashehbf5f32e2011-07-14 21:23:06 +00002956void btrfs_set_root_node(struct btrfs_root_item *item,
2957 struct extent_buffer *node);
Li Zefan08fe4db2011-03-28 02:01:25 +00002958void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
Alexander Block8ea05e32012-07-25 17:35:53 +02002959void btrfs_update_root_times(struct btrfs_trans_handle *trans,
2960 struct btrfs_root *root);
Li Zefan08fe4db2011-03-28 02:01:25 +00002961
Stefan Behrens07b30a42013-08-15 17:11:17 +02002962/* uuid-tree.c */
2963int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans,
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002964 struct btrfs_fs_info *fs_info, u8 *uuid, u8 type,
Stefan Behrens07b30a42013-08-15 17:11:17 +02002965 u64 subid);
2966int btrfs_uuid_tree_rem(struct btrfs_trans_handle *trans,
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04002967 struct btrfs_fs_info *fs_info, u8 *uuid, u8 type,
Stefan Behrens07b30a42013-08-15 17:11:17 +02002968 u64 subid);
Stefan Behrens70f80172013-08-15 17:11:23 +02002969int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
2970 int (*check_func)(struct btrfs_fs_info *, u8 *, u8,
2971 u64));
Stefan Behrens07b30a42013-08-15 17:11:17 +02002972
Chris Masondee26a92007-03-26 16:00:06 -04002973/* dir-item.c */
Chris Mason9c520572012-12-17 14:26:57 -05002974int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
2975 const char *name, int name_len);
Chris Masond3977122009-01-05 21:25:51 -05002976int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
2977 struct btrfs_root *root, const char *name,
Miao Xie16cdcec2011-04-22 18:12:22 +08002978 int name_len, struct inode *dir,
Josef Bacikaec74772008-07-24 12:12:38 -04002979 struct btrfs_key *location, u8 type, u64 index);
Chris Mason7e381802007-04-19 15:36:27 -04002980struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
2981 struct btrfs_root *root,
2982 struct btrfs_path *path, u64 dir,
2983 const char *name, int name_len,
2984 int mod);
2985struct btrfs_dir_item *
2986btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
2987 struct btrfs_root *root,
2988 struct btrfs_path *path, u64 dir,
2989 u64 objectid, const char *name, int name_len,
2990 int mod);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002991struct btrfs_dir_item *
2992btrfs_search_dir_index_item(struct btrfs_root *root,
2993 struct btrfs_path *path, u64 dirid,
2994 const char *name, int name_len);
Chris Mason7e381802007-04-19 15:36:27 -04002995int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
2996 struct btrfs_root *root,
2997 struct btrfs_path *path,
2998 struct btrfs_dir_item *di);
Josef Bacik5103e942007-11-16 11:45:54 -05002999int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
Yan, Zhengf34f57a2009-11-12 09:35:27 +00003000 struct btrfs_root *root,
3001 struct btrfs_path *path, u64 objectid,
3002 const char *name, u16 name_len,
3003 const void *data, u16 data_len);
Josef Bacik5103e942007-11-16 11:45:54 -05003004struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3005 struct btrfs_root *root,
3006 struct btrfs_path *path, u64 dir,
3007 const char *name, u16 name_len,
3008 int mod);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003009int verify_dir_item(struct btrfs_fs_info *fs_info,
Josef Bacik22a94d42011-03-16 16:47:17 -04003010 struct extent_buffer *leaf,
3011 struct btrfs_dir_item *dir_item);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003012struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,
Filipe Manana5f5bc6b2014-11-09 08:38:39 +00003013 struct btrfs_path *path,
3014 const char *name,
3015 int name_len);
Josef Bacik7b128762008-07-24 12:17:14 -04003016
3017/* orphan.c */
3018int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3019 struct btrfs_root *root, u64 offset);
3020int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3021 struct btrfs_root *root, u64 offset);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003022int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
Josef Bacik7b128762008-07-24 12:17:14 -04003023
Chris Masondee26a92007-03-26 16:00:06 -04003024/* inode-item.c */
Chris Mason39544012007-12-12 14:38:19 -05003025int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
3026 struct btrfs_root *root,
3027 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04003028 u64 inode_objectid, u64 ref_objectid, u64 index);
Chris Mason39544012007-12-12 14:38:19 -05003029int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
3030 struct btrfs_root *root,
3031 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04003032 u64 inode_objectid, u64 ref_objectid, u64 *index);
Chris Mason5f39d392007-10-15 16:14:19 -04003033int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
3034 struct btrfs_root *root,
3035 struct btrfs_path *path, u64 objectid);
Chris Mason293ffd52007-03-20 15:57:25 -04003036int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
Chris Masond6e4a422007-04-06 15:37:36 -04003037 *root, struct btrfs_path *path,
3038 struct btrfs_key *location, int mod);
Chris Masondee26a92007-03-26 16:00:06 -04003039
Mark Fashehf1863732012-08-08 11:32:27 -07003040struct btrfs_inode_extref *
3041btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
3042 struct btrfs_root *root,
3043 struct btrfs_path *path,
3044 const char *name, int name_len,
3045 u64 inode_objectid, u64 ref_objectid, int ins_len,
3046 int cow);
3047
3048int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
3049 u64 ref_objectid, const char *name,
3050 int name_len,
3051 struct btrfs_inode_extref **extref_ret);
3052
Chris Masondee26a92007-03-26 16:00:06 -04003053/* file-item.c */
Miao Xiefacc8a222013-07-25 19:22:34 +08003054struct btrfs_dio_private;
Chris Mason459931e2008-12-10 09:10:46 -05003055int btrfs_del_csums(struct btrfs_trans_handle *trans,
Jeff Mahoney5b4aace2016-06-21 10:40:19 -04003056 struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003057int btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst);
3058int btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio,
3059 u64 logical_offset);
Chris Masonb18c6682007-04-17 13:26:50 -04003060int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
Chris Masonc8b97812008-10-29 14:49:59 -04003061 struct btrfs_root *root,
3062 u64 objectid, u64 pos,
3063 u64 disk_offset, u64 disk_num_bytes,
3064 u64 num_bytes, u64 offset, u64 ram_bytes,
3065 u8 compression, u8 encryption, u16 other_encoding);
Chris Masondee26a92007-03-26 16:00:06 -04003066int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3067 struct btrfs_root *root,
3068 struct btrfs_path *path, u64 objectid,
Chris Masondb945352007-10-15 16:15:53 -04003069 u64 bytenr, int mod);
Chris Mason065631f2008-02-20 12:07:25 -05003070int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
Chris Masond20f7042008-12-08 16:58:54 -05003071 struct btrfs_root *root,
Chris Masone6dcd2d2008-07-17 12:53:50 -04003072 struct btrfs_ordered_sum *sums);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003073int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
3074 u64 file_start, int contig);
Arne Jansena2de7332011-03-08 14:14:00 +01003075int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3076 struct list_head *list, int search_commit);
Filipe Manana7ffbb592014-06-09 03:48:05 +01003077void btrfs_extent_item_to_extent_map(struct inode *inode,
3078 const struct btrfs_path *path,
3079 struct btrfs_file_extent_item *fi,
3080 const bool new_inline,
3081 struct extent_map *em);
3082
Chris Mason39279cc2007-06-12 06:35:45 -04003083/* inode.c */
Miao Xie8ccf6f192012-10-25 09:28:04 +00003084struct btrfs_delalloc_work {
3085 struct inode *inode;
Miao Xie8ccf6f192012-10-25 09:28:04 +00003086 int delay_iput;
3087 struct completion completion;
3088 struct list_head list;
3089 struct btrfs_work work;
3090};
3091
3092struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
David Sterba651d4942015-11-27 19:24:16 +01003093 int delay_iput);
Miao Xie8ccf6f192012-10-25 09:28:04 +00003094void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
3095
Josef Bacikb2675152011-07-18 13:21:36 -04003096struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
3097 size_t pg_offset, u64 start, u64 len,
3098 int create);
Josef Bacik00361582013-08-14 14:02:47 -04003099noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
Josef Bacik7ee9e442013-06-21 16:37:03 -04003100 u64 *orig_start, u64 *orig_block_len,
3101 u64 *ram_bytes);
Chris Mason4881ee52008-07-24 09:51:08 -04003102
3103/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
Eric Sandeen5036f532008-08-07 11:19:42 -04003104#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
Chris Mason4881ee52008-07-24 09:51:08 -04003105#define ClearPageChecked ClearPageFsMisc
3106#define SetPageChecked SetPageFsMisc
3107#define PageChecked PageFsMisc
3108#endif
3109
Li Zefanb6973aa2011-07-20 03:46:35 +00003110/* This forces readahead on a given range of bytes in an inode */
3111static inline void btrfs_force_ra(struct address_space *mapping,
3112 struct file_ra_state *ra, struct file *file,
3113 pgoff_t offset, unsigned long req_size)
3114{
3115 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
3116}
3117
Chris Mason3de45862008-11-17 21:02:50 -05003118struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3119int btrfs_set_inode_index(struct inode *dir, u64 *index);
Chris Masone02119d2008-09-05 16:13:11 -04003120int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3121 struct btrfs_root *root,
3122 struct inode *dir, struct inode *inode,
3123 const char *name, int name_len);
3124int btrfs_add_link(struct btrfs_trans_handle *trans,
3125 struct inode *parent_inode, struct inode *inode,
3126 const char *name, int name_len, int add_backref, u64 index);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003127int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3128 struct btrfs_root *root,
3129 struct inode *dir, u64 objectid,
3130 const char *name, int name_len);
Chandan Rajendra9703fef2016-01-21 15:55:56 +05303131int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
Josef Bacik2aaa6652012-08-29 14:27:18 -04003132 int front);
Chris Masone02119d2008-09-05 16:13:11 -04003133int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3134 struct btrfs_root *root,
3135 struct inode *inode, u64 new_size,
3136 u32 min_type);
3137
Yan, Zheng24bbcf02009-11-12 09:36:34 +00003138int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
Miao Xie6c255e62014-03-06 13:55:01 +08003139int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput,
3140 int nr);
Josef Bacik2ac55d42010-02-03 19:33:23 +00003141int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
Qu Wenruoba8b04c2016-07-19 16:50:36 +08003142 struct extent_state **cached_state, int dedupe);
Yan Zhengd2fb3432008-12-11 16:30:39 -05003143int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
Filipe David Borba Manana63541922014-01-07 11:47:46 +00003144 struct btrfs_root *new_root,
3145 struct btrfs_root *parent_root,
3146 u64 new_dirid);
Mike Christie81a75f672016-06-05 14:31:54 -05003147int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
David Woodhouse64a16702009-07-15 23:29:37 +01003148 size_t size, struct bio *bio,
3149 unsigned long bio_flags);
Nick Pigginc2ec1752009-03-31 15:23:21 -07003150int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
Chris Mason9ebefb182007-06-15 13:50:00 -04003151int btrfs_readpage(struct file *file, struct page *page);
Al Virobd555972010-06-07 11:35:40 -04003152void btrfs_evict_inode(struct inode *inode);
Christoph Hellwiga9185b42010-03-05 09:21:37 +01003153int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
Chris Mason39279cc2007-06-12 06:35:45 -04003154struct inode *btrfs_alloc_inode(struct super_block *sb);
3155void btrfs_destroy_inode(struct inode *inode);
Al Viro45321ac2010-06-07 13:43:19 -04003156int btrfs_drop_inode(struct inode *inode);
Chris Mason39279cc2007-06-12 06:35:45 -04003157int btrfs_init_cachep(void);
3158void btrfs_destroy_cachep(void);
Sage Weil6bf13c02008-06-10 10:07:39 -04003159long btrfs_ioctl_trans_end(struct file *file);
Balaji Rao1a54ef82008-07-21 02:01:04 +05303160struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
Josef Bacik73f73412009-12-04 17:38:27 +00003161 struct btrfs_root *root, int *was_new);
Chris Masona52d9a82007-08-27 16:49:44 -04003162struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
David Sterba306e16c2011-04-19 14:29:38 +02003163 size_t pg_offset, u64 start, u64 end,
Chris Masona52d9a82007-08-27 16:49:44 -04003164 int create);
3165int btrfs_update_inode(struct btrfs_trans_handle *trans,
3166 struct btrfs_root *root,
3167 struct inode *inode);
Josef Bacikbe6aef62012-10-22 15:43:12 -04003168int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3169 struct btrfs_root *root, struct inode *inode);
Zheng Yan5b21f2e2008-09-26 10:05:38 -04003170int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
Josef Bacik66b4ffd2011-01-31 16:22:42 -05003171int btrfs_orphan_cleanup(struct btrfs_root *root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04003172void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3173 struct btrfs_root *root);
Josef Bacika41ad392011-01-31 15:30:16 -05003174int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
Jeff Mahoney143bede2012-03-01 14:56:26 +01003175void btrfs_invalidate_inodes(struct btrfs_root *root);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00003176void btrfs_add_delayed_iput(struct inode *inode);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003177void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
Yan, Zhengefa56462010-05-16 10:49:59 -04003178int btrfs_prealloc_file_range(struct inode *inode, int mode,
3179 u64 start, u64 num_bytes, u64 min_size,
3180 loff_t actual_len, u64 *alloc_hint);
Josef Bacik0af3d002010-06-21 14:48:16 -04003181int btrfs_prealloc_file_range_trans(struct inode *inode,
3182 struct btrfs_trans_handle *trans, int mode,
3183 u64 start, u64 num_bytes, u64 min_size,
3184 loff_t actual_len, u64 *alloc_hint);
Alexey Dobriyan82d339d2009-10-09 09:54:36 -04003185extern const struct dentry_operations btrfs_dentry_operations;
Josef Bacik6a3891c2015-03-16 17:38:52 -04003186#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3187void btrfs_test_inode_set_ops(struct inode *inode);
3188#endif
Christoph Hellwigf46b5a62008-06-11 21:53:53 -04003189
3190/* ioctl.c */
3191long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Luke Dashjr4c63c242015-10-29 08:22:21 +00003192long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
David Sterbad5131b62016-02-17 15:26:27 +01003193int btrfs_ioctl_get_supported_features(void __user *arg);
Christoph Hellwig6cbff002009-04-17 10:37:41 +02003194void btrfs_update_iflags(struct inode *inode);
3195void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
Stefan Behrensdd5f9612013-08-15 17:11:20 +02003196int btrfs_is_empty_uuid(u8 *uuid);
Chris Mason4cb53002011-05-24 15:35:30 -04003197int btrfs_defrag_file(struct inode *inode, struct file *file,
3198 struct btrfs_ioctl_defrag_range_args *range,
3199 u64 newer_than, unsigned long max_pages);
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003200void btrfs_get_block_group_info(struct list_head *groups_list,
3201 struct btrfs_ioctl_space_info *space);
Stefan Behrens35a36212013-08-14 18:12:25 +02003202void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
3203 struct btrfs_ioctl_balance_args *bargs);
Darrick J. Wong2b3909f2015-12-19 00:56:05 -08003204ssize_t btrfs_dedupe_file_range(struct file *src_file, u64 loff, u64 olen,
3205 struct file *dst_file, u64 dst_loff);
Stefan Behrens35a36212013-08-14 18:12:25 +02003206
Chris Mason39279cc2007-06-12 06:35:45 -04003207/* file.c */
Miao Xie9247f312012-11-26 09:24:43 +00003208int btrfs_auto_defrag_init(void);
3209void btrfs_auto_defrag_exit(void);
Chris Mason4cb53002011-05-24 15:35:30 -04003210int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3211 struct inode *inode);
3212int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
Miao Xie26176e72012-11-26 09:26:20 +00003213void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
Josef Bacik02c24a82011-07-16 20:44:56 -04003214int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
Josef Bacik7014cdb2012-08-30 20:06:49 -04003215void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
3216 int skip_pinned);
Alexey Dobriyan828c0952009-10-01 15:43:56 -07003217extern const struct file_operations btrfs_file_operations;
Josef Bacik5dc562c2012-08-17 13:14:17 -04003218int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3219 struct btrfs_root *root, struct inode *inode,
3220 struct btrfs_path *path, u64 start, u64 end,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00003221 u64 *drop_end, int drop_cache,
3222 int replace_extent,
3223 u32 extent_item_size,
3224 int *key_inserted);
Josef Bacik5dc562c2012-08-17 13:14:17 -04003225int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3226 struct btrfs_root *root, struct inode *inode, u64 start,
Josef Bacik26714852012-08-29 12:24:27 -04003227 u64 end, int drop_cache);
Yan Zhengd899e052008-10-30 14:25:28 -04003228int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
Yan Zhengd899e052008-10-30 14:25:28 -04003229 struct inode *inode, u64 start, u64 end);
Sage Weil6bf13c02008-06-10 10:07:39 -04003230int btrfs_release_file(struct inode *inode, struct file *file);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003231int btrfs_dirty_pages(struct inode *inode, struct page **pages,
3232 size_t num_pages, loff_t pos, size_t write_bytes,
Josef Bacikbe1a12a2011-04-06 13:05:22 -04003233 struct extent_state **cached);
Filipe Manana728404d2014-10-10 09:43:11 +01003234int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
Zach Brown3db11b22015-11-10 16:53:32 -05003235ssize_t btrfs_copy_file_range(struct file *file_in, loff_t pos_in,
3236 struct file *file_out, loff_t pos_out,
3237 size_t len, unsigned int flags);
Christoph Hellwig04b38d62015-12-03 12:59:50 +01003238int btrfs_clone_file_range(struct file *file_in, loff_t pos_in,
3239 struct file *file_out, loff_t pos_out, u64 len);
Sage Weil6bf13c02008-06-10 10:07:39 -04003240
Chris Mason6702ed42007-08-07 16:15:09 -04003241/* tree-defrag.c */
3242int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
Eric Sandeende78b512013-01-31 18:21:12 +00003243 struct btrfs_root *root);
Josef Bacik58176a92007-08-29 15:47:34 -04003244
3245/* sysfs.c */
3246int btrfs_init_sysfs(void);
3247void btrfs_exit_sysfs(void);
Anand Jain96f31362015-08-14 18:32:46 +08003248int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info);
Anand Jain6618a592015-08-14 18:32:47 +08003249void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info);
Josef Bacik58176a92007-08-29 15:47:34 -04003250
Josef Bacik5103e942007-11-16 11:45:54 -05003251/* xattr.c */
3252ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
Josef Bacik6099afe2008-07-24 12:16:03 -04003253
Chris Masonedbd8d42007-12-21 16:27:24 -05003254/* super.c */
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003255int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
Qu Wenruo96da0912016-01-19 10:23:03 +08003256 unsigned long new_flags);
Sage Weil6bf13c02008-06-10 10:07:39 -04003257int btrfs_sync_fs(struct super_block *sb, int wait);
Joe Perches533574c2012-07-30 14:40:13 -07003258
Arnd Bergmann2fd57fc2016-09-23 18:05:21 +02003259static inline __printf(2, 3)
3260void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
3261{
3262}
3263
Joe Perches533574c2012-07-30 14:40:13 -07003264#ifdef CONFIG_PRINTK
3265__printf(2, 3)
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003266void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
Joe Perches533574c2012-07-30 14:40:13 -07003267#else
Arnd Bergmann2fd57fc2016-09-23 18:05:21 +02003268#define btrfs_printk(fs_info, fmt, args...) \
3269 btrfs_no_printk(fs_info, fmt, ##args)
Joe Perches533574c2012-07-30 14:40:13 -07003270#endif
3271
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003272#define btrfs_emerg(fs_info, fmt, args...) \
3273 btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
3274#define btrfs_alert(fs_info, fmt, args...) \
3275 btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
3276#define btrfs_crit(fs_info, fmt, args...) \
3277 btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
3278#define btrfs_err(fs_info, fmt, args...) \
3279 btrfs_printk(fs_info, KERN_ERR fmt, ##args)
3280#define btrfs_warn(fs_info, fmt, args...) \
3281 btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
3282#define btrfs_notice(fs_info, fmt, args...) \
3283 btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
3284#define btrfs_info(fs_info, fmt, args...) \
3285 btrfs_printk(fs_info, KERN_INFO fmt, ##args)
Frank Holton27a0dd62013-11-12 19:22:53 -05003286
David Sterba08a84e22015-10-08 08:48:52 +02003287/*
3288 * Wrappers that use printk_in_rcu
3289 */
3290#define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
3291 btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3292#define btrfs_alert_in_rcu(fs_info, fmt, args...) \
3293 btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3294#define btrfs_crit_in_rcu(fs_info, fmt, args...) \
3295 btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3296#define btrfs_err_in_rcu(fs_info, fmt, args...) \
3297 btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
3298#define btrfs_warn_in_rcu(fs_info, fmt, args...) \
3299 btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3300#define btrfs_notice_in_rcu(fs_info, fmt, args...) \
3301 btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3302#define btrfs_info_in_rcu(fs_info, fmt, args...) \
3303 btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)
3304
David Sterba24aa6b42015-10-08 10:27:02 +02003305/*
3306 * Wrappers that use a ratelimited printk_in_rcu
3307 */
3308#define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
3309 btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3310#define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
3311 btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3312#define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
3313 btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3314#define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
3315 btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
3316#define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
3317 btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3318#define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
3319 btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3320#define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
3321 btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)
3322
David Sterba1dd6d7c2015-10-08 10:51:11 +02003323/*
3324 * Wrappers that use a ratelimited printk
3325 */
3326#define btrfs_emerg_rl(fs_info, fmt, args...) \
3327 btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
3328#define btrfs_alert_rl(fs_info, fmt, args...) \
3329 btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
3330#define btrfs_crit_rl(fs_info, fmt, args...) \
3331 btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
3332#define btrfs_err_rl(fs_info, fmt, args...) \
3333 btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
3334#define btrfs_warn_rl(fs_info, fmt, args...) \
3335 btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
3336#define btrfs_notice_rl(fs_info, fmt, args...) \
3337 btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
3338#define btrfs_info_rl(fs_info, fmt, args...) \
3339 btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
Jeff Mahoney897a41b2016-08-31 23:55:33 -04003340
3341#if defined(CONFIG_DYNAMIC_DEBUG)
3342#define btrfs_debug(fs_info, fmt, args...) \
3343do { \
3344 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
3345 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
3346 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args); \
3347} while (0)
3348#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3349do { \
3350 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
3351 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
3352 btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args); \
3353} while (0)
3354#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3355do { \
3356 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
3357 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
3358 btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, \
3359 ##args);\
3360} while (0)
3361#define btrfs_debug_rl(fs_info, fmt, args...) \
3362do { \
3363 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
3364 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
3365 btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, \
3366 ##args); \
3367} while (0)
3368#elif defined(DEBUG)
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003369#define btrfs_debug(fs_info, fmt, args...) \
3370 btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
David Sterba08a84e22015-10-08 08:48:52 +02003371#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3372 btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
David Sterba24aa6b42015-10-08 10:27:02 +02003373#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3374 btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
David Sterba1dd6d7c2015-10-08 10:51:11 +02003375#define btrfs_debug_rl(fs_info, fmt, args...) \
3376 btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
Frank Holton27a0dd62013-11-12 19:22:53 -05003377#else
3378#define btrfs_debug(fs_info, fmt, args...) \
Jeff Mahoneyc01f5f92016-09-21 12:17:37 -04003379 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
David Sterba08a84e22015-10-08 08:48:52 +02003380#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
Jeff Mahoneyc01f5f92016-09-21 12:17:37 -04003381 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
David Sterba24aa6b42015-10-08 10:27:02 +02003382#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
Jeff Mahoneyc01f5f92016-09-21 12:17:37 -04003383 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
David Sterba1dd6d7c2015-10-08 10:51:11 +02003384#define btrfs_debug_rl(fs_info, fmt, args...) \
Jeff Mahoneyc01f5f92016-09-21 12:17:37 -04003385 btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
Frank Holton27a0dd62013-11-12 19:22:53 -05003386#endif
Simon Kirbyc2cf52e2013-03-19 22:41:23 +00003387
David Sterba08a84e22015-10-08 08:48:52 +02003388#define btrfs_printk_in_rcu(fs_info, fmt, args...) \
3389do { \
3390 rcu_read_lock(); \
3391 btrfs_printk(fs_info, fmt, ##args); \
3392 rcu_read_unlock(); \
3393} while (0)
3394
David Sterba24aa6b42015-10-08 10:27:02 +02003395#define btrfs_printk_ratelimited(fs_info, fmt, args...) \
3396do { \
3397 static DEFINE_RATELIMIT_STATE(_rs, \
3398 DEFAULT_RATELIMIT_INTERVAL, \
3399 DEFAULT_RATELIMIT_BURST); \
3400 if (__ratelimit(&_rs)) \
3401 btrfs_printk(fs_info, fmt, ##args); \
3402} while (0)
3403
3404#define btrfs_printk_rl_in_rcu(fs_info, fmt, args...) \
3405do { \
3406 rcu_read_lock(); \
3407 btrfs_printk_ratelimited(fs_info, fmt, ##args); \
3408 rcu_read_unlock(); \
3409} while (0)
3410
Josef Bacik2e17c7c62013-08-26 16:53:15 -04003411#ifdef CONFIG_BTRFS_ASSERT
3412
David Sterbac0d19e22015-04-24 19:11:57 +02003413__cold
Josef Bacik2e17c7c62013-08-26 16:53:15 -04003414static inline void assfail(char *expr, char *file, int line)
3415{
Jeff Mahoneyab8d0fc2016-09-20 10:05:02 -04003416 pr_err("assertion failed: %s, file: %s, line: %d\n",
Josef Bacik2e17c7c62013-08-26 16:53:15 -04003417 expr, file, line);
3418 BUG();
3419}
3420
3421#define ASSERT(expr) \
3422 (likely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
3423#else
3424#define ASSERT(expr) ((void)0)
3425#endif
3426
Joe Perches533574c2012-07-30 14:40:13 -07003427__printf(5, 6)
David Sterbac0d19e22015-04-24 19:11:57 +02003428__cold
Anand Jain34d97002016-03-16 16:43:06 +08003429void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
Jeff Mahoney4da35112012-03-01 14:57:30 +01003430 unsigned int line, int errno, const char *fmt, ...);
liuboacce9522011-01-06 19:30:25 +08003431
Jeff Mahoneye33e17e2015-06-15 09:41:19 -04003432const char *btrfs_decode_error(int errno);
Joe Perches533574c2012-07-30 14:40:13 -07003433
David Sterbac0d19e22015-04-24 19:11:57 +02003434__cold
Jeff Mahoney49b25e02012-03-01 17:24:58 +01003435void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
Jeff Mahoney66642832016-06-10 18:19:25 -04003436 const char *function,
Jeff Mahoney49b25e02012-03-01 17:24:58 +01003437 unsigned int line, int errno);
3438
Anand Jainc5f4ccb2016-03-16 16:43:08 +08003439/*
3440 * Call btrfs_abort_transaction as early as possible when an error condition is
3441 * detected, that way the exact line number is reported.
3442 */
Jeff Mahoney66642832016-06-10 18:19:25 -04003443#define btrfs_abort_transaction(trans, errno) \
Anand Jainc5f4ccb2016-03-16 16:43:08 +08003444do { \
3445 /* Report first abort since mount */ \
3446 if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED, \
Jeff Mahoney66642832016-06-10 18:19:25 -04003447 &((trans)->fs_info->fs_state))) { \
Anand Jainc5f4ccb2016-03-16 16:43:08 +08003448 WARN(1, KERN_DEBUG \
3449 "BTRFS: Transaction aborted (error %d)\n", \
3450 (errno)); \
3451 } \
Jeff Mahoney66642832016-06-10 18:19:25 -04003452 __btrfs_abort_transaction((trans), __func__, \
Anand Jainc5f4ccb2016-03-16 16:43:08 +08003453 __LINE__, (errno)); \
3454} while (0)
3455
3456#define btrfs_handle_fs_error(fs_info, errno, fmt, args...) \
3457do { \
3458 __btrfs_handle_fs_error((fs_info), __func__, __LINE__, \
3459 (errno), fmt, ##args); \
3460} while (0)
3461
3462__printf(5, 6)
3463__cold
3464void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3465 unsigned int line, int errno, const char *fmt, ...);
3466/*
3467 * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
3468 * will panic(). Otherwise we BUG() here.
3469 */
3470#define btrfs_panic(fs_info, errno, fmt, args...) \
3471do { \
3472 __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \
3473 BUG(); \
3474} while (0)
3475
3476
3477/* compatibility and incompatibility defines */
3478
Mitch Harder2b0ce2c2012-07-24 11:58:43 -06003479#define btrfs_set_fs_incompat(__fs_info, opt) \
3480 __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3481
3482static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3483 u64 flag)
3484{
3485 struct btrfs_super_block *disk_super;
3486 u64 features;
3487
3488 disk_super = fs_info->super_copy;
3489 features = btrfs_super_incompat_flags(disk_super);
3490 if (!(features & flag)) {
Miao Xieceda0862013-04-11 10:30:16 +00003491 spin_lock(&fs_info->super_lock);
3492 features = btrfs_super_incompat_flags(disk_super);
3493 if (!(features & flag)) {
3494 features |= flag;
3495 btrfs_set_super_incompat_flags(disk_super, features);
Frank Holtonefe120a2013-12-20 11:37:06 -05003496 btrfs_info(fs_info, "setting %llu feature flag",
Miao Xieceda0862013-04-11 10:30:16 +00003497 flag);
3498 }
3499 spin_unlock(&fs_info->super_lock);
Mitch Harder2b0ce2c2012-07-24 11:58:43 -06003500 }
3501}
3502
Omar Sandoval1abfbcd2015-09-29 20:50:32 -07003503#define btrfs_clear_fs_incompat(__fs_info, opt) \
3504 __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3505
3506static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3507 u64 flag)
3508{
3509 struct btrfs_super_block *disk_super;
3510 u64 features;
3511
3512 disk_super = fs_info->super_copy;
3513 features = btrfs_super_incompat_flags(disk_super);
3514 if (features & flag) {
3515 spin_lock(&fs_info->super_lock);
3516 features = btrfs_super_incompat_flags(disk_super);
3517 if (features & flag) {
3518 features &= ~flag;
3519 btrfs_set_super_incompat_flags(disk_super, features);
3520 btrfs_info(fs_info, "clearing %llu feature flag",
3521 flag);
3522 }
3523 spin_unlock(&fs_info->super_lock);
3524 }
3525}
3526
Josef Bacik3173a182013-03-07 14:22:04 -05003527#define btrfs_fs_incompat(fs_info, opt) \
3528 __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3529
Alexandru Moise9780c492015-10-18 21:35:41 +00003530static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
Josef Bacik3173a182013-03-07 14:22:04 -05003531{
3532 struct btrfs_super_block *disk_super;
3533 disk_super = fs_info->super_copy;
3534 return !!(btrfs_super_incompat_flags(disk_super) & flag);
3535}
3536
Omar Sandoval1abfbcd2015-09-29 20:50:32 -07003537#define btrfs_set_fs_compat_ro(__fs_info, opt) \
3538 __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3539
3540static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3541 u64 flag)
3542{
3543 struct btrfs_super_block *disk_super;
3544 u64 features;
3545
3546 disk_super = fs_info->super_copy;
3547 features = btrfs_super_compat_ro_flags(disk_super);
3548 if (!(features & flag)) {
3549 spin_lock(&fs_info->super_lock);
3550 features = btrfs_super_compat_ro_flags(disk_super);
3551 if (!(features & flag)) {
3552 features |= flag;
3553 btrfs_set_super_compat_ro_flags(disk_super, features);
3554 btrfs_info(fs_info, "setting %llu ro feature flag",
3555 flag);
3556 }
3557 spin_unlock(&fs_info->super_lock);
3558 }
3559}
3560
3561#define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3562 __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3563
3564static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3565 u64 flag)
3566{
3567 struct btrfs_super_block *disk_super;
3568 u64 features;
3569
3570 disk_super = fs_info->super_copy;
3571 features = btrfs_super_compat_ro_flags(disk_super);
3572 if (features & flag) {
3573 spin_lock(&fs_info->super_lock);
3574 features = btrfs_super_compat_ro_flags(disk_super);
3575 if (features & flag) {
3576 features &= ~flag;
3577 btrfs_set_super_compat_ro_flags(disk_super, features);
3578 btrfs_info(fs_info, "clearing %llu ro feature flag",
3579 flag);
3580 }
3581 spin_unlock(&fs_info->super_lock);
3582 }
3583}
3584
3585#define btrfs_fs_compat_ro(fs_info, opt) \
3586 __btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3587
3588static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
3589{
3590 struct btrfs_super_block *disk_super;
3591 disk_super = fs_info->super_copy;
3592 return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
3593}
3594
Josef Bacik33268ea2008-07-24 12:16:36 -04003595/* acl.c */
Chris Mason0eda2942009-10-13 13:50:18 -04003596#ifdef CONFIG_BTRFS_FS_POSIX_ACL
Christoph Hellwig4e34e712011-07-23 17:37:31 +02003597struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
Christoph Hellwig996a7102013-12-20 05:16:43 -08003598int btrfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
Yan, Zhengf34f57a2009-11-12 09:35:27 +00003599int btrfs_init_acl(struct btrfs_trans_handle *trans,
3600 struct inode *inode, struct inode *dir);
Li Zefan9b89d952011-07-14 03:17:39 +00003601#else
Linus Torvaldsed8f3732011-08-02 21:14:05 -10003602#define btrfs_get_acl NULL
Christoph Hellwig996a7102013-12-20 05:16:43 -08003603#define btrfs_set_acl NULL
Li Zefan9b89d952011-07-14 03:17:39 +00003604static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
3605 struct inode *inode, struct inode *dir)
3606{
3607 return 0;
3608}
Li Zefan9b89d952011-07-14 03:17:39 +00003609#endif
Josef Bacik0f9dd462008-09-23 13:14:11 -04003610
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003611/* relocation.c */
Jeff Mahoney6bccf3a2016-06-21 21:16:51 -04003612int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003613int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3614 struct btrfs_root *root);
3615int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3616 struct btrfs_root *root);
3617int btrfs_recover_relocation(struct btrfs_root *root);
3618int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
Josef Bacik83d4cfd2013-08-30 15:09:51 -04003619int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3620 struct btrfs_root *root, struct extent_buffer *buf,
3621 struct extent_buffer *cow);
Zhaolei147d2562015-08-06 20:58:11 +08003622void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
Yan, Zheng3fd0a552010-05-16 10:49:59 -04003623 u64 *bytes_to_reserve);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01003624int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
Yan, Zheng3fd0a552010-05-16 10:49:59 -04003625 struct btrfs_pending_snapshot *pending);
Arne Jansena2de7332011-03-08 14:14:00 +01003626
3627/* scrub.c */
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01003628int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
3629 u64 end, struct btrfs_scrub_progress *progress,
Stefan Behrens63a212a2012-11-05 18:29:28 +01003630 int readonly, int is_dev_replace);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003631void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3632void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01003633int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3634int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
3635 struct btrfs_device *dev);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04003636int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
Arne Jansena2de7332011-03-08 14:14:00 +01003637 struct btrfs_scrub_progress *progress);
3638
Miao Xiec404e0d2014-01-30 16:46:55 +08003639/* dev-replace.c */
3640void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
3641void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
Miao Xie42452152014-11-25 16:39:28 +08003642void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);
3643
3644static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
3645{
3646 btrfs_bio_counter_sub(fs_info, 1);
3647}
Miao Xiec404e0d2014-01-30 16:46:55 +08003648
Arne Jansen7414a032011-05-23 14:33:49 +02003649/* reada.c */
3650struct reada_control {
Jeff Mahoneyc28f1582016-06-22 18:56:44 -04003651 struct btrfs_fs_info *fs_info; /* tree to prefetch */
Arne Jansen7414a032011-05-23 14:33:49 +02003652 struct btrfs_key key_start;
3653 struct btrfs_key key_end; /* exclusive */
3654 atomic_t elems;
3655 struct kref refcnt;
3656 wait_queue_head_t wait;
3657};
3658struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3659 struct btrfs_key *start, struct btrfs_key *end);
3660int btrfs_reada_wait(void *handle);
3661void btrfs_reada_detach(void *handle);
Zhao Lei02873e42015-12-31 22:46:45 +08003662int btree_readahead_hook(struct btrfs_fs_info *fs_info,
David Sterbafc2e9012016-11-08 13:50:03 +01003663 struct extent_buffer *eb, int err);
Arne Jansen7414a032011-05-23 14:33:49 +02003664
Jan Schmidt95a06072012-05-29 17:06:54 +02003665static inline int is_fstree(u64 rootid)
3666{
3667 if (rootid == BTRFS_FS_TREE_OBJECTID ||
Qu Wenruoe09fe2d2015-02-27 16:24:23 +08003668 ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
3669 !btrfs_qgroup_level(rootid)))
Jan Schmidt95a06072012-05-29 17:06:54 +02003670 return 1;
3671 return 0;
3672}
David Sterba210549e2013-02-09 23:38:06 +00003673
3674static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
3675{
3676 return signal_pending(current);
3677}
3678
Josef Bacikaaedb552013-10-11 14:44:09 -04003679/* Sanity test specific functions */
3680#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3681void btrfs_test_destroy_inode(struct inode *inode);
3682#endif
David Sterba210549e2013-02-09 23:38:06 +00003683
Jeff Mahoneyf5ee5c92016-06-21 09:52:41 -04003684static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
David Sterbafccb84c2014-09-29 23:53:21 +02003685{
3686#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
Jeff Mahoneyf5ee5c92016-06-21 09:52:41 -04003687 if (unlikely(test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO,
3688 &fs_info->fs_state)))
David Sterbafccb84c2014-09-29 23:53:21 +02003689 return 1;
3690#endif
3691 return 0;
3692}
Chris Masoneb60cea2007-02-02 09:18:22 -05003693#endif