blob: 27ebe61d3cccd0233518d743216dce4b7b8c933f [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>
Josef Bacik58176a92007-08-29 15:47:34 -040026#include <linux/completion.h>
Chris Mason04160082008-03-26 10:28:07 -040027#include <linux/backing-dev.h>
Chris Masone6dcd2d2008-07-17 12:53:50 -040028#include <linux/wait.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Stefan Schmidtf8b18082011-01-12 10:30:42 +010030#include <linux/kobject.h>
liubo1abe9b82011-03-24 11:18:59 +000031#include <trace/events/btrfs.h>
Chris Mason479965d2007-10-15 16:14:27 -040032#include <asm/kmap_types.h>
Josef Bacik3b16a4e2011-09-21 15:05:58 -040033#include <linux/pagemap.h>
Chris Masond1310b22008-01-24 16:13:08 -050034#include "extent_io.h"
Chris Mason5f39d392007-10-15 16:14:19 -040035#include "extent_map.h"
Chris Mason8b712842008-06-11 16:50:36 -040036#include "async-thread.h"
Arne Jansena2de7332011-03-08 14:14:00 +010037#include "ioctl.h"
Chris Masone20d96d2007-03-22 12:13:20 -040038
Chris Masone089f052007-03-16 16:20:31 -040039struct btrfs_trans_handle;
Chris Mason79154b12007-03-22 15:59:16 -040040struct btrfs_transaction;
Yan, Zhenga22285a2010-05-16 10:48:46 -040041struct btrfs_pending_snapshot;
Chris Mason35b7e472007-05-02 15:53:43 -040042extern struct kmem_cache *btrfs_trans_handle_cachep;
43extern struct kmem_cache *btrfs_transaction_cachep;
44extern struct kmem_cache *btrfs_bit_radix_cachep;
Chris Mason2c90e5d2007-04-02 10:50:19 -040045extern struct kmem_cache *btrfs_path_cachep;
Josef Bacikdc89e982011-01-28 17:05:48 -050046extern struct kmem_cache *btrfs_free_space_cachep;
Chris Masone6dcd2d2008-07-17 12:53:50 -040047struct btrfs_ordered_sum;
Chris Masone089f052007-03-16 16:20:31 -040048
Chris Mason2a7108a2008-12-02 09:58:02 -050049#define BTRFS_MAGIC "_BHRfS_M"
Chris Masoneb60cea2007-02-02 09:18:22 -050050
Chris Mason4008c042009-02-12 14:09:45 -050051#define BTRFS_MAX_LEVEL 8
Chris Mason0b86a832008-03-24 15:01:56 -040052
Yan Zheng5d4f98a2009-06-10 10:45:14 -040053#define BTRFS_COMPAT_EXTENT_TREE_V0
54
Chris Mason5a3f23d2009-03-31 13:27:11 -040055/*
56 * files bigger than this get some pre-flushing when they are added
57 * to the ordered operations list. That way we limit the total
58 * work done by the commit
59 */
60#define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
61
Chris Mason0b86a832008-03-24 15:01:56 -040062/* holds pointers to all of the tree roots */
Chris Mason6407bf62007-03-27 06:33:00 -040063#define BTRFS_ROOT_TREE_OBJECTID 1ULL
Chris Mason0b86a832008-03-24 15:01:56 -040064
65/* stores information about which extents are in use, and reference counts */
Chris Mason0cf6c622007-06-09 09:22:25 -040066#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
Chris Mason0b86a832008-03-24 15:01:56 -040067
Chris Mason0b86a832008-03-24 15:01:56 -040068/*
69 * chunk tree stores translations from logical -> physical block numbering
70 * the super block points to the chunk tree
71 */
Chris Masone085def2008-03-24 15:02:07 -040072#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
Chris Mason0b86a832008-03-24 15:01:56 -040073
74/*
75 * stores information about which areas of a given device are in use.
76 * one per device. The tree of tree roots points to the device tree
77 */
Chris Masone085def2008-03-24 15:02:07 -040078#define BTRFS_DEV_TREE_OBJECTID 4ULL
79
80/* one per subvolume, storing files and directories */
81#define BTRFS_FS_TREE_OBJECTID 5ULL
82
83/* directory objectid inside the root tree */
84#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
Chris Mason0b86a832008-03-24 15:01:56 -040085
Chris Masond20f7042008-12-08 16:58:54 -050086/* holds checksums of all the data extents */
87#define BTRFS_CSUM_TREE_OBJECTID 7ULL
88
Ilya Dryomov0940ebf2012-01-16 22:04:48 +020089/* for storing balance parameters in the root tree */
90#define BTRFS_BALANCE_OBJECTID -4ULL
91
Josef Bacik7b128762008-07-24 12:17:14 -040092/* orhpan objectid for tracking unlinked/truncated files */
93#define BTRFS_ORPHAN_OBJECTID -5ULL
94
Chris Masone02119d2008-09-05 16:13:11 -040095/* does write ahead logging to speed up fsyncs */
96#define BTRFS_TREE_LOG_OBJECTID -6ULL
97#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
98
Zheng Yane4657682008-09-26 10:04:53 -040099/* for space balancing */
100#define BTRFS_TREE_RELOC_OBJECTID -8ULL
101#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
102
Chris Masond20f7042008-12-08 16:58:54 -0500103/*
104 * extent checksums all have this objectid
105 * this allows them to share the logging tree
106 * for fsyncs
107 */
108#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
109
Josef Bacik0af3d002010-06-21 14:48:16 -0400110/* For storing free space cache */
111#define BTRFS_FREE_SPACE_OBJECTID -11ULL
112
Li Zefan82d59022011-04-20 10:33:24 +0800113/*
114 * The inode number assigned to the special inode for sotring
115 * free ino cache
116 */
117#define BTRFS_FREE_INO_OBJECTID -12ULL
118
Zheng Yan31840ae2008-09-23 13:14:14 -0400119/* dummy objectid represents multiple objectids */
120#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
121
Chris Mason0b86a832008-03-24 15:01:56 -0400122/*
Zheng Yan6527cdb2008-09-05 16:43:53 -0400123 * All files have objectids in this range.
Chris Mason0b86a832008-03-24 15:01:56 -0400124 */
Chris Masonf6dbff52007-12-13 11:13:32 -0500125#define BTRFS_FIRST_FREE_OBJECTID 256ULL
Zheng Yan6527cdb2008-09-05 16:43:53 -0400126#define BTRFS_LAST_FREE_OBJECTID -256ULL
Chris Masone17cade2008-04-15 15:41:47 -0400127#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
Chris Mason3768f362007-03-13 16:47:54 -0400128
Chris Mason0b86a832008-03-24 15:01:56 -0400129
130/*
131 * the device items go into the chunk tree. The key is in the form
132 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
133 */
134#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
135
Yan, Zheng4df27c4d2009-09-21 15:56:00 -0400136#define BTRFS_BTREE_INODE_OBJECTID 1
137
138#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
139
Chris Masonfec577f2007-02-26 10:40:21 -0500140/*
Chris Masone20d96d2007-03-22 12:13:20 -0400141 * we can actually store much bigger names, but lets not confuse the rest
142 * of linux
143 */
144#define BTRFS_NAME_LEN 255
145
Chris Masonf254e522007-03-29 15:15:27 -0400146/* 32 bytes in various csum fields */
147#define BTRFS_CSUM_SIZE 32
Josef Bacik607d4322008-12-02 07:17:45 -0500148
149/* csum types */
150#define BTRFS_CSUM_TYPE_CRC32 0
151
152static int btrfs_csum_sizes[] = { 4, 0 };
153
Chris Mason509659c2007-05-10 12:36:17 -0400154/* four bytes for CRC32 */
Chris Mason39544012007-12-12 14:38:19 -0500155#define BTRFS_EMPTY_DIR_SIZE 0
Chris Masonf254e522007-03-29 15:15:27 -0400156
Chris Masonfabb5682007-06-07 22:13:21 -0400157#define BTRFS_FT_UNKNOWN 0
158#define BTRFS_FT_REG_FILE 1
159#define BTRFS_FT_DIR 2
160#define BTRFS_FT_CHRDEV 3
161#define BTRFS_FT_BLKDEV 4
162#define BTRFS_FT_FIFO 5
163#define BTRFS_FT_SOCK 6
164#define BTRFS_FT_SYMLINK 7
Josef Bacik5103e942007-11-16 11:45:54 -0500165#define BTRFS_FT_XATTR 8
166#define BTRFS_FT_MAX 9
Chris Masonfabb5682007-06-07 22:13:21 -0400167
Chris Masone20d96d2007-03-22 12:13:20 -0400168/*
Wu Fengguangd4a78942009-04-02 16:46:06 -0400169 * The key defines the order in the tree, and so it also defines (optimal)
170 * block layout.
171 *
172 * objectid corresponds to the inode number.
173 *
174 * type tells us things about the object, and is a kind of stream selector.
175 * so for a given inode, keys with type of 1 might refer to the inode data,
176 * type of 2 may point to file data in the btree and type == 3 may point to
177 * extents.
Chris Masonfec577f2007-02-26 10:40:21 -0500178 *
179 * offset is the starting byte offset for this key in the stream.
Chris Masone2fa7222007-03-12 16:22:34 -0400180 *
181 * btrfs_disk_key is in disk byte order. struct btrfs_key is always
182 * in cpu native order. Otherwise they are identical and their sizes
183 * should be the same (ie both packed)
Chris Masonfec577f2007-02-26 10:40:21 -0500184 */
Chris Masone2fa7222007-03-12 16:22:34 -0400185struct btrfs_disk_key {
186 __le64 objectid;
Chris Mason5f39d392007-10-15 16:14:19 -0400187 u8 type;
Chris Mason70b2bef2007-04-17 15:39:32 -0400188 __le64 offset;
Chris Masone2fa7222007-03-12 16:22:34 -0400189} __attribute__ ((__packed__));
190
191struct btrfs_key {
Chris Masoneb60cea2007-02-02 09:18:22 -0500192 u64 objectid;
Chris Mason5f39d392007-10-15 16:14:19 -0400193 u8 type;
Chris Mason70b2bef2007-04-17 15:39:32 -0400194 u64 offset;
Chris Masoneb60cea2007-02-02 09:18:22 -0500195} __attribute__ ((__packed__));
196
Chris Mason0b86a832008-03-24 15:01:56 -0400197struct btrfs_mapping_tree {
198 struct extent_map_tree map_tree;
199};
200
Chris Mason0b86a832008-03-24 15:01:56 -0400201struct btrfs_dev_item {
202 /* the internal btrfs device id */
203 __le64 devid;
204
205 /* size of the device */
206 __le64 total_bytes;
207
208 /* bytes used */
209 __le64 bytes_used;
210
211 /* optimal io alignment for this device */
212 __le32 io_align;
213
214 /* optimal io width for this device */
215 __le32 io_width;
216
217 /* minimal io size for this device */
218 __le32 sector_size;
219
Chris Mason0b86a832008-03-24 15:01:56 -0400220 /* type and info about this device */
221 __le64 type;
222
Yan Zheng2b820322008-11-17 21:11:30 -0500223 /* expected generation for this device */
224 __le64 generation;
225
Chris Masonc3027eb2008-12-08 16:40:21 -0500226 /*
227 * starting byte of this partition on the device,
Wu Fengguangd4a78942009-04-02 16:46:06 -0400228 * to allow for stripe alignment in the future
Chris Masonc3027eb2008-12-08 16:40:21 -0500229 */
230 __le64 start_offset;
231
Chris Masone17cade2008-04-15 15:41:47 -0400232 /* grouping information for allocation decisions */
233 __le32 dev_group;
234
235 /* seek speed 0-100 where 100 is fastest */
236 u8 seek_speed;
237
238 /* bandwidth 0-100 where 100 is fastest */
239 u8 bandwidth;
240
Chris Mason0d81ba52008-03-24 15:02:07 -0400241 /* btrfs generated uuid for this device */
Chris Masone17cade2008-04-15 15:41:47 -0400242 u8 uuid[BTRFS_UUID_SIZE];
Yan Zheng2b820322008-11-17 21:11:30 -0500243
244 /* uuid of FS who owns this device */
245 u8 fsid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400246} __attribute__ ((__packed__));
247
248struct btrfs_stripe {
249 __le64 devid;
250 __le64 offset;
Chris Masone17cade2008-04-15 15:41:47 -0400251 u8 dev_uuid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400252} __attribute__ ((__packed__));
253
254struct btrfs_chunk {
Chris Masone17cade2008-04-15 15:41:47 -0400255 /* size of this chunk in bytes */
256 __le64 length;
257
258 /* objectid of the root referencing this chunk */
Chris Mason0b86a832008-03-24 15:01:56 -0400259 __le64 owner;
Chris Masone17cade2008-04-15 15:41:47 -0400260
Chris Mason0b86a832008-03-24 15:01:56 -0400261 __le64 stripe_len;
262 __le64 type;
263
264 /* optimal io alignment for this chunk */
265 __le32 io_align;
266
267 /* optimal io width for this chunk */
268 __le32 io_width;
269
270 /* minimal io size for this chunk */
271 __le32 sector_size;
272
273 /* 2^16 stripes is quite a lot, a second limit is the size of a single
274 * item in the btree
275 */
276 __le16 num_stripes;
Chris Mason321aecc2008-04-16 10:49:51 -0400277
278 /* sub stripes only matter for raid10 */
279 __le16 sub_stripes;
Chris Mason0b86a832008-03-24 15:01:56 -0400280 struct btrfs_stripe stripe;
281 /* additional stripes go here */
282} __attribute__ ((__packed__));
283
Josef Bacik0af3d002010-06-21 14:48:16 -0400284#define BTRFS_FREE_SPACE_EXTENT 1
285#define BTRFS_FREE_SPACE_BITMAP 2
286
287struct btrfs_free_space_entry {
288 __le64 offset;
289 __le64 bytes;
290 u8 type;
291} __attribute__ ((__packed__));
292
293struct btrfs_free_space_header {
294 struct btrfs_disk_key location;
295 __le64 generation;
296 __le64 num_entries;
297 __le64 num_bitmaps;
298} __attribute__ ((__packed__));
299
Chris Mason0b86a832008-03-24 15:01:56 -0400300static inline unsigned long btrfs_chunk_item_size(int num_stripes)
301{
302 BUG_ON(num_stripes == 0);
303 return sizeof(struct btrfs_chunk) +
304 sizeof(struct btrfs_stripe) * (num_stripes - 1);
305}
306
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400307#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
308#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
liuboacce9522011-01-06 19:30:25 +0800309
310/*
311 * File system states
312 */
313
314/* Errors detected */
315#define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)
316
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400317#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
318#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
319
320#define BTRFS_BACKREF_REV_MAX 256
321#define BTRFS_BACKREF_REV_SHIFT 56
322#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
323 BTRFS_BACKREF_REV_SHIFT)
324
325#define BTRFS_OLD_BACKREF_REV 0
326#define BTRFS_MIXED_BACKREF_REV 1
Chris Mason63b10fc2008-04-01 11:21:32 -0400327
Chris Masonfec577f2007-02-26 10:40:21 -0500328/*
329 * every tree block (leaf or node) starts with this header.
330 */
Chris Masonbb492bb2007-03-12 12:29:44 -0400331struct btrfs_header {
Chris Masone17cade2008-04-15 15:41:47 -0400332 /* these first four must match the super block */
Chris Masonf254e522007-03-29 15:15:27 -0400333 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason5f39d392007-10-15 16:14:19 -0400334 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400335 __le64 bytenr; /* which block this node is supposed to live in */
Chris Mason63b10fc2008-04-01 11:21:32 -0400336 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400337
338 /* allowed to be different from the super from here on down */
339 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason7f5c1512007-03-23 15:56:19 -0400340 __le64 generation;
Chris Mason4d775672007-04-20 20:23:12 -0400341 __le64 owner;
Chris Mason5f39d392007-10-15 16:14:19 -0400342 __le32 nritems;
Chris Mason9a6f11e2007-03-27 09:06:38 -0400343 u8 level;
Chris Masoneb60cea2007-02-02 09:18:22 -0500344} __attribute__ ((__packed__));
345
Chris Mason5f39d392007-10-15 16:14:19 -0400346#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
Chris Masond3977122009-01-05 21:25:51 -0500347 sizeof(struct btrfs_header)) / \
348 sizeof(struct btrfs_key_ptr))
Chris Mason123abc82007-03-14 14:14:43 -0400349#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
Chris Mason5f39d392007-10-15 16:14:19 -0400350#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
Chris Mason236454df2007-04-19 13:37:44 -0400351#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
352 sizeof(struct btrfs_item) - \
353 sizeof(struct btrfs_file_extent_item))
Yan, Zhengf34f57a2009-11-12 09:35:27 +0000354#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
355 sizeof(struct btrfs_item) -\
356 sizeof(struct btrfs_dir_item))
Chris Masoneb60cea2007-02-02 09:18:22 -0500357
Chris Mason0b86a832008-03-24 15:01:56 -0400358
359/*
360 * this is a very generous portion of the super block, giving us
361 * room to translate 14 chunks with 3 stripes each.
362 */
363#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
Chris Mason7ae9c092008-04-18 10:29:49 -0400364#define BTRFS_LABEL_SIZE 256
Chris Mason0b86a832008-03-24 15:01:56 -0400365
Chris Masonfec577f2007-02-26 10:40:21 -0500366/*
Chris Masonaf31f5e2011-11-03 15:17:42 -0400367 * just in case we somehow lose the roots and are not able to mount,
368 * we store an array of the roots from previous transactions
369 * in the super.
370 */
371#define BTRFS_NUM_BACKUP_ROOTS 4
372struct btrfs_root_backup {
373 __le64 tree_root;
374 __le64 tree_root_gen;
375
376 __le64 chunk_root;
377 __le64 chunk_root_gen;
378
379 __le64 extent_root;
380 __le64 extent_root_gen;
381
382 __le64 fs_root;
383 __le64 fs_root_gen;
384
385 __le64 dev_root;
386 __le64 dev_root_gen;
387
388 __le64 csum_root;
389 __le64 csum_root_gen;
390
391 __le64 total_bytes;
392 __le64 bytes_used;
393 __le64 num_devices;
394 /* future */
395 __le64 unsed_64[4];
396
397 u8 tree_root_level;
398 u8 chunk_root_level;
399 u8 extent_root_level;
400 u8 fs_root_level;
401 u8 dev_root_level;
402 u8 csum_root_level;
403 /* future and to align */
404 u8 unused_8[10];
405} __attribute__ ((__packed__));
406
407/*
Chris Masonfec577f2007-02-26 10:40:21 -0500408 * the super block basically lists the main trees of the FS
409 * it currently lacks any block count etc etc
410 */
Chris Mason234b63a2007-03-13 10:46:10 -0400411struct btrfs_super_block {
Chris Masonf254e522007-03-29 15:15:27 -0400412 u8 csum[BTRFS_CSUM_SIZE];
Chris Mason63b10fc2008-04-01 11:21:32 -0400413 /* the first 4 fields must match struct btrfs_header */
Yan Zheng2b820322008-11-17 21:11:30 -0500414 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
Chris Masondb945352007-10-15 16:15:53 -0400415 __le64 bytenr; /* this block number */
Chris Mason63b10fc2008-04-01 11:21:32 -0400416 __le64 flags;
Chris Masone17cade2008-04-15 15:41:47 -0400417
418 /* allowed to be different from the btrfs_header from here own down */
Chris Mason3768f362007-03-13 16:47:54 -0400419 __le64 magic;
Chris Mason3768f362007-03-13 16:47:54 -0400420 __le64 generation;
421 __le64 root;
Chris Mason0b86a832008-03-24 15:01:56 -0400422 __le64 chunk_root;
Chris Masone02119d2008-09-05 16:13:11 -0400423 __le64 log_root;
Chris Masonc3027eb2008-12-08 16:40:21 -0500424
425 /* this will help find the new super based on the log root */
426 __le64 log_root_transid;
Chris Masondb945352007-10-15 16:15:53 -0400427 __le64 total_bytes;
428 __le64 bytes_used;
Chris Mason2e635a22007-03-21 11:12:56 -0400429 __le64 root_dir_objectid;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400430 __le64 num_devices;
Chris Mason5f39d392007-10-15 16:14:19 -0400431 __le32 sectorsize;
432 __le32 nodesize;
433 __le32 leafsize;
Chris Mason87ee04e2007-11-30 11:30:34 -0500434 __le32 stripesize;
Chris Mason0b86a832008-03-24 15:01:56 -0400435 __le32 sys_chunk_array_size;
Yan Zheng84234f32008-10-29 14:49:05 -0400436 __le64 chunk_root_generation;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500437 __le64 compat_flags;
438 __le64 compat_ro_flags;
439 __le64 incompat_flags;
Josef Bacik607d4322008-12-02 07:17:45 -0500440 __le16 csum_type;
Chris Masondb945352007-10-15 16:15:53 -0400441 u8 root_level;
Chris Mason0b86a832008-03-24 15:01:56 -0400442 u8 chunk_root_level;
Chris Masone02119d2008-09-05 16:13:11 -0400443 u8 log_root_level;
Chris Mason0d81ba52008-03-24 15:02:07 -0400444 struct btrfs_dev_item dev_item;
Chris Masonc3027eb2008-12-08 16:40:21 -0500445
Chris Mason7ae9c092008-04-18 10:29:49 -0400446 char label[BTRFS_LABEL_SIZE];
Chris Masonc3027eb2008-12-08 16:40:21 -0500447
Josef Bacik0af3d002010-06-21 14:48:16 -0400448 __le64 cache_generation;
449
Chris Masonc3027eb2008-12-08 16:40:21 -0500450 /* future expansion */
Josef Bacik0af3d002010-06-21 14:48:16 -0400451 __le64 reserved[31];
Chris Mason0b86a832008-03-24 15:01:56 -0400452 u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
Chris Masonaf31f5e2011-11-03 15:17:42 -0400453 struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
Chris Masoncfaa7292007-02-21 17:04:57 -0500454} __attribute__ ((__packed__));
455
Chris Masonfec577f2007-02-26 10:40:21 -0500456/*
Josef Bacikf2b636e2008-12-02 06:36:08 -0500457 * Compat flags that we support. If any incompat flags are set other than the
458 * ones specified below then we will fail to mount
459 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400460#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
Josef Bacik0af3d002010-06-21 14:48:16 -0400461#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
Josef Bacik67377732010-09-16 16:19:09 -0400462#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2)
Li Zefana6fa6fa2010-10-25 15:12:26 +0800463#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400464
465#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
466#define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
Josef Bacik0af3d002010-06-21 14:48:16 -0400467#define BTRFS_FEATURE_INCOMPAT_SUPP \
468 (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
Josef Bacik67377732010-09-16 16:19:09 -0400469 BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL | \
Li Zefana6fa6fa2010-10-25 15:12:26 +0800470 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS | \
471 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO)
Josef Bacikf2b636e2008-12-02 06:36:08 -0500472
473/*
Chris Mason62e27492007-03-15 12:56:47 -0400474 * A leaf is full of items. offset and size tell us where to find
Chris Masonfec577f2007-02-26 10:40:21 -0500475 * the item in the leaf (relative to the start of the data area)
476 */
Chris Mason0783fcf2007-03-12 20:12:07 -0400477struct btrfs_item {
Chris Masone2fa7222007-03-12 16:22:34 -0400478 struct btrfs_disk_key key;
Chris Mason123abc82007-03-14 14:14:43 -0400479 __le32 offset;
Chris Mason5f39d392007-10-15 16:14:19 -0400480 __le32 size;
Chris Masoneb60cea2007-02-02 09:18:22 -0500481} __attribute__ ((__packed__));
482
Chris Masonfec577f2007-02-26 10:40:21 -0500483/*
484 * leaves have an item area and a data area:
485 * [item0, item1....itemN] [free space] [dataN...data1, data0]
486 *
487 * The data is separate from the items to get the keys closer together
488 * during searches.
489 */
Chris Mason234b63a2007-03-13 10:46:10 -0400490struct btrfs_leaf {
Chris Masonbb492bb2007-03-12 12:29:44 -0400491 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400492 struct btrfs_item items[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500493} __attribute__ ((__packed__));
494
Chris Masonfec577f2007-02-26 10:40:21 -0500495/*
496 * all non-leaf blocks are nodes, they hold only keys and pointers to
497 * other blocks
498 */
Chris Mason123abc82007-03-14 14:14:43 -0400499struct btrfs_key_ptr {
500 struct btrfs_disk_key key;
501 __le64 blockptr;
Chris Mason74493f72007-12-11 09:25:06 -0500502 __le64 generation;
Chris Mason123abc82007-03-14 14:14:43 -0400503} __attribute__ ((__packed__));
504
Chris Mason234b63a2007-03-13 10:46:10 -0400505struct btrfs_node {
Chris Masonbb492bb2007-03-12 12:29:44 -0400506 struct btrfs_header header;
Chris Mason123abc82007-03-14 14:14:43 -0400507 struct btrfs_key_ptr ptrs[];
Chris Masoneb60cea2007-02-02 09:18:22 -0500508} __attribute__ ((__packed__));
509
Chris Masonfec577f2007-02-26 10:40:21 -0500510/*
Chris Mason234b63a2007-03-13 10:46:10 -0400511 * btrfs_paths remember the path taken from the root down to the leaf.
512 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
Chris Masonfec577f2007-02-26 10:40:21 -0500513 * to any other levels that are present.
514 *
515 * The slots array records the index of the item or block pointer
516 * used while walking the tree.
517 */
Chris Mason234b63a2007-03-13 10:46:10 -0400518struct btrfs_path {
Chris Mason5f39d392007-10-15 16:14:19 -0400519 struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
Chris Mason234b63a2007-03-13 10:46:10 -0400520 int slots[BTRFS_MAX_LEVEL];
Chris Mason925baed2008-06-25 16:01:30 -0400521 /* if there is real range locking, this locks field will change */
522 int locks[BTRFS_MAX_LEVEL];
Chris Mason3c69fae2007-08-07 15:52:22 -0400523 int reada;
Chris Mason925baed2008-06-25 16:01:30 -0400524 /* keep some upper locks as we walk down */
Chris Mason6702ed42007-08-07 16:15:09 -0400525 int lowest_level;
Chris Mason459931e2008-12-10 09:10:46 -0500526
527 /*
528 * set by btrfs_split_item, tells search_slot to keep all locks
529 * and to force calls to keep space in the nodes
530 */
Chris Masonb9473432009-03-13 11:00:37 -0400531 unsigned int search_for_split:1;
532 unsigned int keep_locks:1;
533 unsigned int skip_locking:1;
534 unsigned int leave_spinning:1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400535 unsigned int search_commit_root:1;
Chris Masoneb60cea2007-02-02 09:18:22 -0500536};
Chris Mason5de08d72007-02-24 06:24:44 -0500537
Chris Mason62e27492007-03-15 12:56:47 -0400538/*
539 * items in the extent btree are used to record the objectid of the
540 * owner of the block and the number of references
541 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400542
Chris Mason62e27492007-03-15 12:56:47 -0400543struct btrfs_extent_item {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400544 __le64 refs;
545 __le64 generation;
546 __le64 flags;
547} __attribute__ ((__packed__));
548
549struct btrfs_extent_item_v0 {
Chris Mason62e27492007-03-15 12:56:47 -0400550 __le32 refs;
Chris Mason74493f72007-12-11 09:25:06 -0500551} __attribute__ ((__packed__));
552
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400553#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
554 sizeof(struct btrfs_item))
555
556#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
557#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
558
559/* following flags only apply to tree blocks */
560
561/* use full backrefs for extent pointers in the block */
562#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
563
Arne Jansena2de7332011-03-08 14:14:00 +0100564/*
565 * this flag is only used internally by scrub and may be changed at any time
566 * it is only declared here to avoid collisions
567 */
568#define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)
569
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400570struct btrfs_tree_block_info {
571 struct btrfs_disk_key key;
572 u8 level;
573} __attribute__ ((__packed__));
574
575struct btrfs_extent_data_ref {
576 __le64 root;
577 __le64 objectid;
578 __le64 offset;
579 __le32 count;
580} __attribute__ ((__packed__));
581
582struct btrfs_shared_data_ref {
583 __le32 count;
584} __attribute__ ((__packed__));
585
586struct btrfs_extent_inline_ref {
587 u8 type;
Yan Zheng1bec1ae2009-07-22 09:59:00 -0400588 __le64 offset;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400589} __attribute__ ((__packed__));
590
591/* old style backrefs item */
592struct btrfs_extent_ref_v0 {
Chris Mason74493f72007-12-11 09:25:06 -0500593 __le64 root;
594 __le64 generation;
595 __le64 objectid;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400596 __le32 count;
Chris Mason62e27492007-03-15 12:56:47 -0400597} __attribute__ ((__packed__));
598
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400599
Chris Mason0b86a832008-03-24 15:01:56 -0400600/* dev extents record free space on individual devices. The owner
601 * field points back to the chunk allocation mapping tree that allocated
Chris Masone17cade2008-04-15 15:41:47 -0400602 * the extent. The chunk tree uuid field is a way to double check the owner
Chris Mason0b86a832008-03-24 15:01:56 -0400603 */
604struct btrfs_dev_extent {
Chris Masone17cade2008-04-15 15:41:47 -0400605 __le64 chunk_tree;
606 __le64 chunk_objectid;
607 __le64 chunk_offset;
Chris Mason0b86a832008-03-24 15:01:56 -0400608 __le64 length;
Chris Masone17cade2008-04-15 15:41:47 -0400609 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason0b86a832008-03-24 15:01:56 -0400610} __attribute__ ((__packed__));
611
Chris Mason39544012007-12-12 14:38:19 -0500612struct btrfs_inode_ref {
Josef Bacikaec74772008-07-24 12:12:38 -0400613 __le64 index;
Chris Mason39544012007-12-12 14:38:19 -0500614 __le16 name_len;
615 /* name goes here */
616} __attribute__ ((__packed__));
617
Chris Mason0b86a832008-03-24 15:01:56 -0400618struct btrfs_timespec {
Chris Masonf254e522007-03-29 15:15:27 -0400619 __le64 sec;
Chris Mason1e1d2702007-03-15 19:03:33 -0400620 __le32 nsec;
621} __attribute__ ((__packed__));
622
Jan Engelhardt95029d72009-01-21 10:49:16 -0500623enum btrfs_compression_type {
Li Zefan261507a02010-12-17 14:21:50 +0800624 BTRFS_COMPRESS_NONE = 0,
625 BTRFS_COMPRESS_ZLIB = 1,
Li Zefana6fa6fa2010-10-25 15:12:26 +0800626 BTRFS_COMPRESS_LZO = 2,
627 BTRFS_COMPRESS_TYPES = 2,
628 BTRFS_COMPRESS_LAST = 3,
Jan Engelhardt95029d72009-01-21 10:49:16 -0500629};
Chris Masonc8b97812008-10-29 14:49:59 -0400630
Chris Mason1e1d2702007-03-15 19:03:33 -0400631struct btrfs_inode_item {
Chris Masone02119d2008-09-05 16:13:11 -0400632 /* nfs style generation number */
Chris Mason1e1d2702007-03-15 19:03:33 -0400633 __le64 generation;
Chris Masone02119d2008-09-05 16:13:11 -0400634 /* transid that last touched this inode */
635 __le64 transid;
Chris Mason1e1d2702007-03-15 19:03:33 -0400636 __le64 size;
Yan Zhenga76a3cd2008-10-09 11:46:29 -0400637 __le64 nbytes;
Chris Mason31f3c992007-04-30 15:25:45 -0400638 __le64 block_group;
Chris Mason1e1d2702007-03-15 19:03:33 -0400639 __le32 nlink;
640 __le32 uid;
641 __le32 gid;
642 __le32 mode;
Chris Mason0b86a832008-03-24 15:01:56 -0400643 __le64 rdev;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500644 __le64 flags;
Chris Masonc8b97812008-10-29 14:49:59 -0400645
Chris Masonc3027eb2008-12-08 16:40:21 -0500646 /* modification sequence number for NFS */
647 __le64 sequence;
648
649 /*
650 * a little future expansion, for more than this we can
651 * just grow the inode item and version it
652 */
653 __le64 reserved[4];
Chris Mason0b86a832008-03-24 15:01:56 -0400654 struct btrfs_timespec atime;
655 struct btrfs_timespec ctime;
656 struct btrfs_timespec mtime;
657 struct btrfs_timespec otime;
Chris Mason1e1d2702007-03-15 19:03:33 -0400658} __attribute__ ((__packed__));
659
Chris Masone02119d2008-09-05 16:13:11 -0400660struct btrfs_dir_log_item {
661 __le64 end;
662} __attribute__ ((__packed__));
663
Chris Mason62e27492007-03-15 12:56:47 -0400664struct btrfs_dir_item {
Chris Masond6e4a422007-04-06 15:37:36 -0400665 struct btrfs_disk_key location;
Chris Masone02119d2008-09-05 16:13:11 -0400666 __le64 transid;
Josef Bacik5103e942007-11-16 11:45:54 -0500667 __le16 data_len;
Chris Masona8a2ee02007-03-16 08:46:49 -0400668 __le16 name_len;
Chris Mason62e27492007-03-15 12:56:47 -0400669 u8 type;
670} __attribute__ ((__packed__));
671
Li Zefanb83cc962010-12-20 16:04:08 +0800672#define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)
673
Chris Mason62e27492007-03-15 12:56:47 -0400674struct btrfs_root_item {
Chris Masond6e4a422007-04-06 15:37:36 -0400675 struct btrfs_inode_item inode;
Yan Zheng84234f32008-10-29 14:49:05 -0400676 __le64 generation;
Chris Masond6e4a422007-04-06 15:37:36 -0400677 __le64 root_dirid;
Chris Masondb945352007-10-15 16:15:53 -0400678 __le64 bytenr;
679 __le64 byte_limit;
680 __le64 bytes_used;
Yan Zheng80ff3852008-10-30 14:20:02 -0400681 __le64 last_snapshot;
Josef Bacikf2b636e2008-12-02 06:36:08 -0500682 __le64 flags;
Chris Mason62e27492007-03-15 12:56:47 -0400683 __le32 refs;
Chris Mason5eda7b52007-06-22 14:16:25 -0400684 struct btrfs_disk_key drop_progress;
685 u8 drop_level;
Chris Masondb945352007-10-15 16:15:53 -0400686 u8 level;
Chris Mason9f5fae22007-03-20 14:38:32 -0400687} __attribute__ ((__packed__));
688
Chris Mason0660b5a2008-11-17 20:37:39 -0500689/*
690 * this is used for both forward and backward root refs
691 */
692struct btrfs_root_ref {
693 __le64 dirid;
694 __le64 sequence;
695 __le16 name_len;
696} __attribute__ ((__packed__));
697
Ilya Dryomov0940ebf2012-01-16 22:04:48 +0200698struct btrfs_disk_balance_args {
699 /*
700 * profiles to operate on, single is denoted by
701 * BTRFS_AVAIL_ALLOC_BIT_SINGLE
702 */
703 __le64 profiles;
704
705 /* usage filter */
706 __le64 usage;
707
708 /* devid filter */
709 __le64 devid;
710
711 /* devid subset filter [pstart..pend) */
712 __le64 pstart;
713 __le64 pend;
714
715 /* btrfs virtual address space subset filter [vstart..vend) */
716 __le64 vstart;
717 __le64 vend;
718
719 /*
720 * profile to convert to, single is denoted by
721 * BTRFS_AVAIL_ALLOC_BIT_SINGLE
722 */
723 __le64 target;
724
725 /* BTRFS_BALANCE_ARGS_* */
726 __le64 flags;
727
728 __le64 unused[8];
729} __attribute__ ((__packed__));
730
731/*
732 * store balance parameters to disk so that balance can be properly
733 * resumed after crash or unmount
734 */
735struct btrfs_balance_item {
736 /* BTRFS_BALANCE_* */
737 __le64 flags;
738
739 struct btrfs_disk_balance_args data;
740 struct btrfs_disk_balance_args meta;
741 struct btrfs_disk_balance_args sys;
742
743 __le64 unused[4];
744} __attribute__ ((__packed__));
745
Yan Zhengd899e052008-10-30 14:25:28 -0400746#define BTRFS_FILE_EXTENT_INLINE 0
747#define BTRFS_FILE_EXTENT_REG 1
748#define BTRFS_FILE_EXTENT_PREALLOC 2
Chris Mason236454df2007-04-19 13:37:44 -0400749
Chris Mason9f5fae22007-03-20 14:38:32 -0400750struct btrfs_file_extent_item {
Chris Masonc8b97812008-10-29 14:49:59 -0400751 /*
752 * transaction id that created this extent
753 */
Chris Mason71951f32007-03-27 09:16:29 -0400754 __le64 generation;
Chris Masonc8b97812008-10-29 14:49:59 -0400755 /*
756 * max number of bytes to hold this extent in ram
757 * when we split a compressed extent we can't know how big
758 * each of the resulting pieces will be. So, this is
759 * an upper limit on the size of the extent in ram instead of
760 * an exact limit.
761 */
762 __le64 ram_bytes;
763
764 /*
765 * 32 bits for the various ways we might encode the data,
766 * including compression and encryption. If any of these
767 * are set to something a given disk format doesn't understand
768 * it is treated like an incompat flag for reading and writing,
769 * but not for stat.
770 */
771 u8 compression;
772 u8 encryption;
773 __le16 other_encoding; /* spare for later use */
774
775 /* are we inline data or a real extent? */
Chris Mason236454df2007-04-19 13:37:44 -0400776 u8 type;
Chris Masonc8b97812008-10-29 14:49:59 -0400777
Chris Mason9f5fae22007-03-20 14:38:32 -0400778 /*
779 * disk space consumed by the extent, checksum blocks are included
780 * in these numbers
781 */
Chris Masondb945352007-10-15 16:15:53 -0400782 __le64 disk_bytenr;
783 __le64 disk_num_bytes;
Chris Mason9f5fae22007-03-20 14:38:32 -0400784 /*
Chris Masondee26a92007-03-26 16:00:06 -0400785 * the logical offset in file blocks (no csums)
Chris Mason9f5fae22007-03-20 14:38:32 -0400786 * this extent record is for. This allows a file extent to point
787 * into the middle of an existing extent on disk, sharing it
788 * between two snapshots (useful if some bytes in the middle of the
789 * extent have changed
790 */
791 __le64 offset;
792 /*
Chris Masonc8b97812008-10-29 14:49:59 -0400793 * the logical number of file blocks (no csums included). This
794 * always reflects the size uncompressed and without encoding.
Chris Mason9f5fae22007-03-20 14:38:32 -0400795 */
Chris Masondb945352007-10-15 16:15:53 -0400796 __le64 num_bytes;
Chris Masonc8b97812008-10-29 14:49:59 -0400797
Chris Mason9f5fae22007-03-20 14:38:32 -0400798} __attribute__ ((__packed__));
799
Chris Masonf254e522007-03-29 15:15:27 -0400800struct btrfs_csum_item {
Chris Mason509659c2007-05-10 12:36:17 -0400801 u8 csum;
Chris Masonf254e522007-03-29 15:15:27 -0400802} __attribute__ ((__packed__));
803
Chris Mason0b86a832008-03-24 15:01:56 -0400804/* different types of block groups (and chunks) */
Ilya Dryomov52ba6922012-01-16 22:04:47 +0200805#define BTRFS_BLOCK_GROUP_DATA (1ULL << 0)
806#define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1)
807#define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2)
808#define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3)
809#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)
810#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)
811#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
Ilya Dryomova46d11a2012-01-16 22:04:47 +0200812#define BTRFS_BLOCK_GROUP_RESERVED BTRFS_AVAIL_ALLOC_BIT_SINGLE
Ilya Dryomov52ba6922012-01-16 22:04:47 +0200813#define BTRFS_NR_RAID_TYPES 5
Chris Mason1e2677e2007-05-29 16:52:18 -0400814
Ilya Dryomov52ba6922012-01-16 22:04:47 +0200815#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \
816 BTRFS_BLOCK_GROUP_SYSTEM | \
817 BTRFS_BLOCK_GROUP_METADATA)
818
819#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \
820 BTRFS_BLOCK_GROUP_RAID1 | \
821 BTRFS_BLOCK_GROUP_DUP | \
822 BTRFS_BLOCK_GROUP_RAID10)
Ilya Dryomova46d11a2012-01-16 22:04:47 +0200823/*
824 * We need a bit for restriper to be able to tell when chunks of type
825 * SINGLE are available. This "extended" profile format is used in
826 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields
827 * (on-disk). The corresponding on-disk bit in chunk.type is reserved
828 * to avoid remappings between two formats in future.
829 */
830#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)
831
Chris Mason9078a3e2007-04-26 16:46:15 -0400832struct btrfs_block_group_item {
833 __le64 used;
Chris Mason0b86a832008-03-24 15:01:56 -0400834 __le64 chunk_objectid;
835 __le64 flags;
Chris Mason9078a3e2007-04-26 16:46:15 -0400836} __attribute__ ((__packed__));
837
Chris Mason6324fbf2008-03-24 15:01:59 -0400838struct btrfs_space_info {
839 u64 flags;
Josef Bacik6a632092009-02-20 11:00:09 -0500840
Josef Bacik89a55892010-10-14 14:52:27 -0400841 u64 total_bytes; /* total bytes in the space,
842 this doesn't take mirrors into account */
Yan, Zhengb742bb82010-05-16 10:46:24 -0400843 u64 bytes_used; /* total bytes used,
Lucas De Marchie9c54992011-04-26 23:28:26 -0700844 this doesn't take mirrors into account */
Josef Bacik6a632092009-02-20 11:00:09 -0500845 u64 bytes_pinned; /* total bytes pinned, will be freed when the
846 transaction finishes */
847 u64 bytes_reserved; /* total bytes the allocator has reserved for
848 current allocations */
849 u64 bytes_readonly; /* total bytes that are read only */
Yan, Zheng8929ecfa2010-05-16 10:49:58 -0400850
Josef Bacik6a632092009-02-20 11:00:09 -0500851 u64 bytes_may_use; /* number of bytes that may be used for
Josef Bacik9ed74f22009-09-11 16:12:44 -0400852 delalloc/allocations */
Yan, Zhengb742bb82010-05-16 10:46:24 -0400853 u64 disk_used; /* total bytes used on disk */
Josef Bacik89a55892010-10-14 14:52:27 -0400854 u64 disk_total; /* total bytes on disk, takes mirrors into
855 account */
Josef Bacik6a632092009-02-20 11:00:09 -0500856
Chris Mason36e39c42011-03-12 07:08:42 -0500857 /*
858 * we bump reservation progress every time we decrement
859 * bytes_reserved. This way people waiting for reservations
860 * know something good has happened and they can check
861 * for progress. The number here isn't to be trusted, it
862 * just shows reclaim activity
863 */
864 unsigned long reservation_progress;
865
David Sterba4ea02882011-05-12 18:13:12 +0200866 unsigned int full:1; /* indicates that we cannot allocate any more
Josef Bacik6a632092009-02-20 11:00:09 -0500867 chunks for this space */
David Sterba4ea02882011-05-12 18:13:12 +0200868 unsigned int chunk_alloc:1; /* set if we are allocating a chunk */
Josef Bacik6d741192011-04-11 20:20:11 -0400869
Josef Bacikfdb5eff2011-06-07 16:07:44 -0400870 unsigned int flush:1; /* set if we are trying to make space */
871
David Sterba4ea02882011-05-12 18:13:12 +0200872 unsigned int force_alloc; /* set if we need to force a chunk
873 alloc for this space */
Josef Bacik6a632092009-02-20 11:00:09 -0500874
Chris Mason6324fbf2008-03-24 15:01:59 -0400875 struct list_head list;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400876
877 /* for block groups in our same type */
Yan, Zhengb742bb82010-05-16 10:46:24 -0400878 struct list_head block_groups[BTRFS_NR_RAID_TYPES];
Josef Bacik0f9dd462008-09-23 13:14:11 -0400879 spinlock_t lock;
Josef Bacik80eb2342008-10-29 14:49:05 -0400880 struct rw_semaphore groups_sem;
Josef Bacikfdb5eff2011-06-07 16:07:44 -0400881 wait_queue_head_t wait;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400882};
883
Yan, Zhengf0486c62010-05-16 10:46:25 -0400884struct btrfs_block_rsv {
885 u64 size;
886 u64 reserved;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400887 struct btrfs_space_info *space_info;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400888 spinlock_t lock;
Yan, Zhengf0486c62010-05-16 10:46:25 -0400889 unsigned int full:1;
890};
891
Chris Masonfa9c0d792009-04-03 09:47:43 -0400892/*
893 * free clusters are used to claim free space in relatively large chunks,
894 * allowing us to do less seeky writes. They are used for all metadata
895 * allocations and data allocations in ssd mode.
896 */
897struct btrfs_free_cluster {
898 spinlock_t lock;
899 spinlock_t refill_lock;
900 struct rb_root root;
901
902 /* largest extent in this cluster */
903 u64 max_size;
904
905 /* first extent starting offset */
906 u64 window_start;
907
908 struct btrfs_block_group_cache *block_group;
909 /*
910 * when a cluster is allocated from a block group, we put the
911 * cluster onto a list in the block group so that it can
912 * be freed before the block group is freed.
913 */
914 struct list_head block_group_list;
Chris Mason6324fbf2008-03-24 15:01:59 -0400915};
916
Josef Bacik817d52f2009-07-13 21:29:25 -0400917enum btrfs_caching_type {
918 BTRFS_CACHE_NO = 0,
919 BTRFS_CACHE_STARTED = 1,
Josef Bacik291c7d22011-11-14 13:52:14 -0500920 BTRFS_CACHE_FAST = 2,
921 BTRFS_CACHE_FINISHED = 3,
Josef Bacik817d52f2009-07-13 21:29:25 -0400922};
923
Josef Bacik0af3d002010-06-21 14:48:16 -0400924enum btrfs_disk_cache_state {
925 BTRFS_DC_WRITTEN = 0,
926 BTRFS_DC_ERROR = 1,
927 BTRFS_DC_CLEAR = 2,
928 BTRFS_DC_SETUP = 3,
929 BTRFS_DC_NEED_WRITE = 4,
930};
931
Yan Zheng11833d62009-09-11 16:11:19 -0400932struct btrfs_caching_control {
933 struct list_head list;
934 struct mutex mutex;
935 wait_queue_head_t wait;
Josef Bacikbab39bf2011-06-30 14:42:28 -0400936 struct btrfs_work work;
Yan Zheng11833d62009-09-11 16:11:19 -0400937 struct btrfs_block_group_cache *block_group;
938 u64 progress;
939 atomic_t count;
940};
941
Chris Mason9078a3e2007-04-26 16:46:15 -0400942struct btrfs_block_group_cache {
943 struct btrfs_key key;
944 struct btrfs_block_group_item item;
Josef Bacik817d52f2009-07-13 21:29:25 -0400945 struct btrfs_fs_info *fs_info;
Josef Bacik0af3d002010-06-21 14:48:16 -0400946 struct inode *inode;
Chris Masonc286ac42008-07-22 23:06:41 -0400947 spinlock_t lock;
Yan324ae4d2007-11-16 14:57:08 -0500948 u64 pinned;
Zheng Yane8569812008-09-26 10:05:48 -0400949 u64 reserved;
Josef Bacik1b2da372009-09-11 16:11:20 -0400950 u64 bytes_super;
Chris Mason0b86a832008-03-24 15:01:56 -0400951 u64 flags;
Josef Bacik96303082009-07-13 21:29:25 -0400952 u64 sectorsize;
Josef Bacik5b0e95b2011-10-06 08:58:24 -0400953 u64 cache_generation;
Mariusz Kozlowski0410c942010-11-20 12:03:07 +0000954 unsigned int ro:1;
955 unsigned int dirty:1;
956 unsigned int iref:1;
Josef Bacik0af3d002010-06-21 14:48:16 -0400957
958 int disk_cache_state;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400959
Josef Bacik817d52f2009-07-13 21:29:25 -0400960 /* cache tracking stuff */
Josef Bacik817d52f2009-07-13 21:29:25 -0400961 int cached;
Yan Zheng11833d62009-09-11 16:11:19 -0400962 struct btrfs_caching_control *caching_ctl;
963 u64 last_byte_to_unpin;
Josef Bacik817d52f2009-07-13 21:29:25 -0400964
Josef Bacik0f9dd462008-09-23 13:14:11 -0400965 struct btrfs_space_info *space_info;
966
967 /* free space cache stuff */
Li Zefan34d52cb2011-03-29 13:46:06 +0800968 struct btrfs_free_space_ctl *free_space_ctl;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400969
970 /* block group cache stuff */
971 struct rb_node cache_node;
972
973 /* for block groups in the same raid type */
974 struct list_head list;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500975
976 /* usage count */
977 atomic_t count;
Chris Masonfa9c0d792009-04-03 09:47:43 -0400978
979 /* List of struct btrfs_free_clusters for this block group.
980 * Today it will only have one thing on it, but that may change
981 */
982 struct list_head cluster_list;
Chris Mason9078a3e2007-04-26 16:46:15 -0400983};
Chris Mason0b86a832008-03-24 15:01:56 -0400984
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400985struct reloc_control;
Chris Mason0b86a832008-03-24 15:01:56 -0400986struct btrfs_device;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400987struct btrfs_fs_devices;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +0200988struct btrfs_balance_control;
Miao Xie16cdcec2011-04-22 18:12:22 +0800989struct btrfs_delayed_root;
Chris Mason9f5fae22007-03-20 14:38:32 -0400990struct btrfs_fs_info {
Chris Mason5f39d392007-10-15 16:14:19 -0400991 u8 fsid[BTRFS_FSID_SIZE];
Chris Masone17cade2008-04-15 15:41:47 -0400992 u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
Chris Mason9f5fae22007-03-20 14:38:32 -0400993 struct btrfs_root *extent_root;
994 struct btrfs_root *tree_root;
Chris Mason0b86a832008-03-24 15:01:56 -0400995 struct btrfs_root *chunk_root;
996 struct btrfs_root *dev_root;
Chris Mason3de45862008-11-17 21:02:50 -0500997 struct btrfs_root *fs_root;
Chris Masond20f7042008-12-08 16:58:54 -0500998 struct btrfs_root *csum_root;
Chris Masone02119d2008-09-05 16:13:11 -0400999
1000 /* the log root tree is a directory of all the other log roots */
1001 struct btrfs_root *log_root_tree;
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001002
1003 spinlock_t fs_roots_radix_lock;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001004 struct radix_tree_root fs_roots_radix;
Chris Mason1a5bc162007-10-15 16:15:26 -04001005
Josef Bacik0f9dd462008-09-23 13:14:11 -04001006 /* block group cache stuff */
1007 spinlock_t block_group_cache_lock;
1008 struct rb_root block_group_cache_tree;
1009
Josef Bacik2bf64752011-09-26 17:12:22 -04001010 /* keep track of unallocated space */
1011 spinlock_t free_chunk_lock;
1012 u64 free_chunk_space;
1013
Yan Zheng11833d62009-09-11 16:11:19 -04001014 struct extent_io_tree freed_extents[2];
1015 struct extent_io_tree *pinned_extents;
Chris Mason1a5bc162007-10-15 16:15:26 -04001016
Chris Mason0b86a832008-03-24 15:01:56 -04001017 /* logical->physical extent mapping */
1018 struct btrfs_mapping_tree mapping_tree;
1019
Miao Xie16cdcec2011-04-22 18:12:22 +08001020 /*
1021 * block reservation for extent, checksum, root tree and
1022 * delayed dir index item
1023 */
Yan, Zhengf0486c62010-05-16 10:46:25 -04001024 struct btrfs_block_rsv global_block_rsv;
1025 /* block reservation for delay allocation */
1026 struct btrfs_block_rsv delalloc_block_rsv;
1027 /* block reservation for metadata operations */
1028 struct btrfs_block_rsv trans_block_rsv;
1029 /* block reservation for chunk tree */
1030 struct btrfs_block_rsv chunk_block_rsv;
Josef Bacik6d668dd2011-11-03 22:54:25 -04001031 /* block reservation for delayed operations */
1032 struct btrfs_block_rsv delayed_block_rsv;
Yan, Zhengf0486c62010-05-16 10:46:25 -04001033
1034 struct btrfs_block_rsv empty_block_rsv;
1035
Chris Mason293ffd52007-03-20 15:57:25 -04001036 u64 generation;
Josef Bacik15ee9bc2007-08-10 16:22:09 -04001037 u64 last_trans_committed;
Chris Mason12fcfd22009-03-24 10:24:20 -04001038
1039 /*
1040 * this is updated to the current trans every time a full commit
1041 * is required instead of the faster short fsync log commits
1042 */
1043 u64 last_trans_log_full_commit;
Stefan Behrens21adbd52011-11-09 13:44:05 +01001044 unsigned long mount_opt:21;
Li Zefan261507a02010-12-17 14:21:50 +08001045 unsigned long compress_type:4;
Chris Mason6f568d32008-01-29 16:03:38 -05001046 u64 max_inline;
Chris Mason8f662a72008-01-02 10:01:11 -05001047 u64 alloc_start;
Chris Mason79154b12007-03-22 15:59:16 -04001048 struct btrfs_transaction *running_transaction;
Chris Masone6dcd2d2008-07-17 12:53:50 -04001049 wait_queue_head_t transaction_throttle;
Chris Masonf9295742008-07-17 12:54:14 -04001050 wait_queue_head_t transaction_wait;
Sage Weilbb9c12c2010-10-29 15:37:34 -04001051 wait_queue_head_t transaction_blocked_wait;
Chris Mason771ed682008-11-06 22:02:51 -05001052 wait_queue_head_t async_submit_wait;
Chris Masone02119d2008-09-05 16:13:11 -04001053
David Sterba6c417612011-04-13 15:41:04 +02001054 struct btrfs_super_block *super_copy;
1055 struct btrfs_super_block *super_for_commit;
Chris Mason0b86a832008-03-24 15:01:56 -04001056 struct block_device *__bdev;
Chris Masone20d96d2007-03-22 12:13:20 -04001057 struct super_block *sb;
Chris Masond98237b2007-03-28 13:57:48 -04001058 struct inode *btree_inode;
Chris Mason04160082008-03-26 10:28:07 -04001059 struct backing_dev_info bdi;
Chris Masone02119d2008-09-05 16:13:11 -04001060 struct mutex tree_log_mutex;
Chris Masona74a4b92008-06-25 16:01:31 -04001061 struct mutex transaction_kthread_mutex;
1062 struct mutex cleaner_mutex;
Chris Mason925baed2008-06-25 16:01:30 -04001063 struct mutex chunk_mutex;
Chris Mason7d9eb122008-07-08 14:19:17 -04001064 struct mutex volume_mutex;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001065 /*
1066 * this protects the ordered operations list only while we are
1067 * processing all of the entries on it. This way we make
1068 * sure the commit code doesn't find the list temporarily empty
1069 * because another function happens to be doing non-waiting preflush
1070 * before jumping into the main commit.
1071 */
1072 struct mutex ordered_operations_mutex;
Yan Zheng11833d62009-09-11 16:11:19 -04001073 struct rw_semaphore extent_commit_sem;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001074
Yan, Zhengc71bf092009-11-12 09:34:40 +00001075 struct rw_semaphore cleanup_work_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -04001076
Yan, Zhengc71bf092009-11-12 09:34:40 +00001077 struct rw_semaphore subvol_sem;
Yan, Zheng76dda932009-09-21 16:00:26 -04001078 struct srcu_struct subvol_srcu;
1079
Josef Bacika4abeea2011-04-11 17:25:13 -04001080 spinlock_t trans_lock;
Chris Mason75857172011-06-13 20:00:16 -04001081 /*
1082 * the reloc mutex goes with the trans lock, it is taken
1083 * during commit to protect us from the relocation code
1084 */
1085 struct mutex reloc_mutex;
1086
Chris Mason8fd17792007-04-19 21:01:03 -04001087 struct list_head trans_list;
Chris Mason19c00dd2007-10-15 16:19:22 -04001088 struct list_head hashers;
Chris Masonfacda1e2007-06-08 18:11:48 -04001089 struct list_head dead_roots;
Yan Zheng11833d62009-09-11 16:11:19 -04001090 struct list_head caching_block_groups;
Chris Masone02119d2008-09-05 16:13:11 -04001091
Yan, Zheng24bbcf02009-11-12 09:36:34 +00001092 spinlock_t delayed_iput_lock;
1093 struct list_head delayed_iputs;
1094
Chris Masoncb03c742008-05-15 16:15:45 -04001095 atomic_t nr_async_submits;
Chris Mason8c8bee12008-09-29 11:19:10 -04001096 atomic_t async_submit_draining;
Chris Mason0986fe9e2008-08-15 15:34:15 -04001097 atomic_t nr_async_bios;
Chris Mason771ed682008-11-06 22:02:51 -05001098 atomic_t async_delalloc_pages;
Josef Bacika4abeea2011-04-11 17:25:13 -04001099 atomic_t open_ioctl_trans;
Chris Masonce9adaa2008-04-09 16:28:12 -04001100
Chris Mason8b712842008-06-11 16:50:36 -04001101 /*
Chris Mason3eaa2882008-07-24 11:57:52 -04001102 * this is used by the balancing code to wait for all the pending
1103 * ordered extents
1104 */
1105 spinlock_t ordered_extent_lock;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001106
1107 /*
1108 * all of the data=ordered extents pending writeback
1109 * these can span multiple transactions and basically include
1110 * every dirty data page that isn't from nodatacow
1111 */
Chris Mason3eaa2882008-07-24 11:57:52 -04001112 struct list_head ordered_extents;
Chris Mason5a3f23d2009-03-31 13:27:11 -04001113
1114 /*
1115 * all of the inodes that have delalloc bytes. It is possible for
1116 * this list to be empty even when there is still dirty data=ordered
1117 * extents waiting to finish IO.
1118 */
Chris Masonea8c2812008-08-04 23:17:27 -04001119 struct list_head delalloc_inodes;
Chris Mason3eaa2882008-07-24 11:57:52 -04001120
1121 /*
Chris Mason5a3f23d2009-03-31 13:27:11 -04001122 * special rename and truncate targets that must be on disk before
1123 * we're allowed to commit. This is basically the ext3 style
1124 * data=ordered list.
1125 */
1126 struct list_head ordered_operations;
1127
1128 /*
Chris Mason8b712842008-06-11 16:50:36 -04001129 * there is a pool of worker threads for checksumming during writes
1130 * and a pool for checksumming after reads. This is because readers
1131 * can run with FS locks held, and the writers may be waiting for
1132 * those locks. We don't want ordering in the pending list to cause
1133 * deadlocks, and so the two are serviced separately.
Chris Mason1cc127b2008-06-12 14:46:17 -04001134 *
1135 * A third pool does submit_bio to avoid deadlocking with the other
1136 * two
Chris Mason8b712842008-06-11 16:50:36 -04001137 */
Chris Mason61d92c32009-10-02 19:11:56 -04001138 struct btrfs_workers generic_worker;
Chris Mason8b712842008-06-11 16:50:36 -04001139 struct btrfs_workers workers;
Chris Mason771ed682008-11-06 22:02:51 -05001140 struct btrfs_workers delalloc_workers;
Chris Mason8b712842008-06-11 16:50:36 -04001141 struct btrfs_workers endio_workers;
Chris Masond20f7042008-12-08 16:58:54 -05001142 struct btrfs_workers endio_meta_workers;
Chris Masoncad321a2008-12-17 14:51:42 -05001143 struct btrfs_workers endio_meta_write_workers;
Chris Masone6dcd2d2008-07-17 12:53:50 -04001144 struct btrfs_workers endio_write_workers;
Josef Bacik0cb59c92010-07-02 12:14:14 -04001145 struct btrfs_workers endio_freespace_worker;
Chris Mason1cc127b2008-06-12 14:46:17 -04001146 struct btrfs_workers submit_workers;
Josef Bacikbab39bf2011-06-30 14:42:28 -04001147 struct btrfs_workers caching_workers;
Arne Jansen90519d62011-05-23 14:30:00 +02001148 struct btrfs_workers readahead_workers;
Josef Bacikbab39bf2011-06-30 14:42:28 -04001149
Chris Mason247e7432008-07-17 12:53:51 -04001150 /*
1151 * fixup workers take dirty pages that didn't properly go through
1152 * the cow mechanism and make them safe to write. It happens
1153 * for the sys_munmap function call path
1154 */
1155 struct btrfs_workers fixup_workers;
Miao Xie16cdcec2011-04-22 18:12:22 +08001156 struct btrfs_workers delayed_workers;
Chris Masona74a4b92008-06-25 16:01:31 -04001157 struct task_struct *transaction_kthread;
1158 struct task_struct *cleaner_kthread;
Chris Mason4543df72008-06-11 21:47:56 -04001159 int thread_pool_size;
Chris Mason8b712842008-06-11 16:50:36 -04001160
Josef Bacik58176a92007-08-29 15:47:34 -04001161 struct kobject super_kobj;
1162 struct completion kobj_unregister;
Chris Masone66f7092007-04-20 13:16:02 -04001163 int do_barriers;
Chris Masonfacda1e2007-06-08 18:11:48 -04001164 int closing;
Chris Masone02119d2008-09-05 16:13:11 -04001165 int log_root_recovering;
Yan, Zhenga22285a2010-05-16 10:48:46 -04001166 int enospc_unlink;
Josef Bacika4abeea2011-04-11 17:25:13 -04001167 int trans_no_join;
Chris Mason62e27492007-03-15 12:56:47 -04001168
Yan324ae4d2007-11-16 14:57:08 -05001169 u64 total_pinned;
Chris Masonb9473432009-03-13 11:00:37 -04001170
1171 /* protected by the delalloc lock, used to keep from writing
1172 * metadata until there is a nice batch
1173 */
1174 u64 dirty_metadata_bytes;
Chris Mason0b86a832008-03-24 15:01:56 -04001175 struct list_head dirty_cowonly_roots;
1176
Chris Mason8a4b83c2008-03-24 15:02:07 -04001177 struct btrfs_fs_devices *fs_devices;
Chris Mason4184ea72009-03-10 12:39:20 -04001178
1179 /*
1180 * the space_info list is almost entirely read only. It only changes
1181 * when we add a new raid type to the FS, and that happens
1182 * very rarely. RCU is used to protect it.
1183 */
Chris Mason6324fbf2008-03-24 15:01:59 -04001184 struct list_head space_info;
Chris Mason4184ea72009-03-10 12:39:20 -04001185
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001186 struct reloc_control *reloc_ctl;
1187
Chris Mason1832a6d2007-12-21 16:27:21 -05001188 spinlock_t delalloc_lock;
1189 u64 delalloc_bytes;
Chris Masonfa9c0d792009-04-03 09:47:43 -04001190
1191 /* data_alloc_cluster is only used in ssd mode */
1192 struct btrfs_free_cluster data_alloc_cluster;
1193
1194 /* all metadata allocations go through this cluster */
1195 struct btrfs_free_cluster meta_alloc_cluster;
Chris Masond18a2c42008-04-04 15:40:00 -04001196
Chris Mason4cb53002011-05-24 15:35:30 -04001197 /* auto defrag inodes go here */
1198 spinlock_t defrag_inodes_lock;
1199 struct rb_root defrag_inodes;
1200 atomic_t defrag_running;
1201
Yan Zheng31153d82008-07-28 15:32:19 -04001202 spinlock_t ref_cache_lock;
1203 u64 total_ref_cache_size;
Yan Zheng31153d82008-07-28 15:32:19 -04001204
Ilya Dryomova46d11a2012-01-16 22:04:47 +02001205 /*
1206 * these three are in extended format (availability of single
1207 * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
1208 * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
1209 */
Chris Masond18a2c42008-04-04 15:40:00 -04001210 u64 avail_data_alloc_bits;
1211 u64 avail_metadata_alloc_bits;
1212 u64 avail_system_alloc_bits;
Chris Mason788f20e2008-04-28 15:29:42 -04001213
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001214 /* restriper state */
1215 spinlock_t balance_lock;
1216 struct mutex balance_mutex;
Ilya Dryomov837d5b62012-01-16 22:04:49 +02001217 atomic_t balance_running;
1218 atomic_t balance_pause_req;
Ilya Dryomova7e99c62012-01-16 22:04:49 +02001219 atomic_t balance_cancel_req;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001220 struct btrfs_balance_control *balance_ctl;
Ilya Dryomov837d5b62012-01-16 22:04:49 +02001221 wait_queue_head_t balance_wait_q;
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02001222
Josef Bacik97e728d2009-04-21 17:40:57 -04001223 unsigned data_chunk_allocations;
1224 unsigned metadata_ratio;
1225
Chris Mason788f20e2008-04-28 15:29:42 -04001226 void *bdev_holder;
liuboacce9522011-01-06 19:30:25 +08001227
Arne Jansena2de7332011-03-08 14:14:00 +01001228 /* private scrub information */
1229 struct mutex scrub_lock;
1230 atomic_t scrubs_running;
1231 atomic_t scrub_pause_req;
1232 atomic_t scrubs_paused;
1233 atomic_t scrub_cancel_req;
1234 wait_queue_head_t scrub_pause_wait;
1235 struct rw_semaphore scrub_super_lock;
1236 int scrub_workers_refcnt;
1237 struct btrfs_workers scrub_workers;
1238
Stefan Behrens21adbd52011-11-09 13:44:05 +01001239#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1240 u32 check_integrity_print_mask;
1241#endif
1242
liuboacce9522011-01-06 19:30:25 +08001243 /* filesystem state */
1244 u64 fs_state;
Miao Xie16cdcec2011-04-22 18:12:22 +08001245
1246 struct btrfs_delayed_root *delayed_root;
Chris Masonaf31f5e2011-11-03 15:17:42 -04001247
Arne Jansen90519d62011-05-23 14:30:00 +02001248 /* readahead tree */
1249 spinlock_t reada_lock;
1250 struct radix_tree_root reada_tree;
Chris Mason531f4b1a2011-11-06 03:05:08 -05001251
Chris Masonaf31f5e2011-11-03 15:17:42 -04001252 /* next backup root to be overwritten */
1253 int backup_root_index;
Yan324ae4d2007-11-16 14:57:08 -05001254};
Chris Mason0b86a832008-03-24 15:01:56 -04001255
Chris Mason62e27492007-03-15 12:56:47 -04001256/*
1257 * in ram representation of the tree. extent_root is used for all allocations
Chris Masonf2458e12007-04-25 15:52:25 -04001258 * and for the extent tree extent_root root.
Chris Mason62e27492007-03-15 12:56:47 -04001259 */
1260struct btrfs_root {
Chris Mason5f39d392007-10-15 16:14:19 -04001261 struct extent_buffer *node;
Chris Mason925baed2008-06-25 16:01:30 -04001262
Chris Mason5f39d392007-10-15 16:14:19 -04001263 struct extent_buffer *commit_root;
Chris Masone02119d2008-09-05 16:13:11 -04001264 struct btrfs_root *log_root;
Zheng Yan1a40e232008-09-26 10:09:34 -04001265 struct btrfs_root *reloc_root;
Yan Zheng31153d82008-07-28 15:32:19 -04001266
Chris Mason62e27492007-03-15 12:56:47 -04001267 struct btrfs_root_item root_item;
1268 struct btrfs_key root_key;
Chris Mason9f5fae22007-03-20 14:38:32 -04001269 struct btrfs_fs_info *fs_info;
Chris Masond0c803c2008-09-11 16:17:57 -04001270 struct extent_io_tree dirty_log_pages;
1271
Josef Bacik58176a92007-08-29 15:47:34 -04001272 struct kobject root_kobj;
1273 struct completion kobj_unregister;
Chris Masona2135012008-06-25 16:01:30 -04001274 struct mutex objectid_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001275
Yan, Zhengf0486c62010-05-16 10:46:25 -04001276 spinlock_t accounting_lock;
1277 struct btrfs_block_rsv *block_rsv;
1278
Li Zefan581bb052011-04-20 10:06:11 +08001279 /* free ino cache stuff */
1280 struct mutex fs_commit_mutex;
1281 struct btrfs_free_space_ctl *free_ino_ctl;
1282 enum btrfs_caching_type cached;
1283 spinlock_t cache_lock;
1284 wait_queue_head_t cache_wait;
1285 struct btrfs_free_space_ctl *free_ino_pinned;
1286 u64 cache_progress;
Li Zefan82d59022011-04-20 10:33:24 +08001287 struct inode *cache_inode;
Li Zefan581bb052011-04-20 10:06:11 +08001288
Chris Masone02119d2008-09-05 16:13:11 -04001289 struct mutex log_mutex;
Yan Zheng7237f182009-01-21 12:54:03 -05001290 wait_queue_head_t log_writer_wait;
1291 wait_queue_head_t log_commit_wait[2];
1292 atomic_t log_writers;
1293 atomic_t log_commit[2];
1294 unsigned long log_transid;
Chris Mason257c62e2009-10-13 13:21:08 -04001295 unsigned long last_log_commit;
Yan Zheng7237f182009-01-21 12:54:03 -05001296 unsigned long log_batch;
Josef Bacikff782e02009-10-08 15:30:04 -04001297 pid_t log_start_pid;
1298 bool log_multiple_pids;
Chris Masonea8c2812008-08-04 23:17:27 -04001299
Chris Mason0f7d52f2007-04-09 10:42:37 -04001300 u64 objectid;
1301 u64 last_trans;
Chris Mason5f39d392007-10-15 16:14:19 -04001302
1303 /* data allocations are done in sectorsize units */
1304 u32 sectorsize;
1305
1306 /* node allocations are done in nodesize units */
1307 u32 nodesize;
1308
1309 /* leaf allocations are done in leafsize units */
1310 u32 leafsize;
1311
Chris Mason87ee04e2007-11-30 11:30:34 -05001312 u32 stripesize;
1313
Chris Mason9f5fae22007-03-20 14:38:32 -04001314 u32 type;
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001315
1316 u64 highest_objectid;
Chris Mason75857172011-06-13 20:00:16 -04001317
1318 /* btrfs_record_root_in_trans is a multi-step process,
1319 * and it can race with the balancing code. But the
1320 * race is very small, and only the first time the root
1321 * is added to each transaction. So in_trans_setup
1322 * is used to tell us when more checks are required
1323 */
1324 unsigned long in_trans_setup;
Chris Mason9f3a7422007-08-07 15:52:19 -04001325 int ref_cows;
Chris Mason0b86a832008-03-24 15:01:56 -04001326 int track_dirty;
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001327 int in_radix;
1328
Chris Mason3f157a22008-06-25 16:01:31 -04001329 u64 defrag_trans_start;
Chris Mason6702ed42007-08-07 16:15:09 -04001330 struct btrfs_key defrag_progress;
Chris Mason0ef3e662008-05-24 14:04:53 -04001331 struct btrfs_key defrag_max;
Chris Mason6702ed42007-08-07 16:15:09 -04001332 int defrag_running;
Josef Bacik58176a92007-08-29 15:47:34 -04001333 char *name;
Chris Mason0b86a832008-03-24 15:01:56 -04001334
1335 /* the dirty list is only used by non-reference counted roots */
1336 struct list_head dirty_list;
Josef Bacik7b128762008-07-24 12:17:14 -04001337
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001338 struct list_head root_list;
1339
Yan, Zhengd68fc572010-05-16 10:49:58 -04001340 spinlock_t orphan_lock;
Josef Bacik7b128762008-07-24 12:17:14 -04001341 struct list_head orphan_list;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001342 struct btrfs_block_rsv *orphan_block_rsv;
1343 int orphan_item_inserted;
1344 int orphan_cleanup_state;
Chris Mason3394e162008-11-17 20:42:26 -05001345
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001346 spinlock_t inode_lock;
1347 /* red-black tree that keeps track of in-memory inodes */
1348 struct rb_root inode_tree;
1349
Chris Mason3394e162008-11-17 20:42:26 -05001350 /*
Miao Xie16cdcec2011-04-22 18:12:22 +08001351 * radix tree that keeps track of delayed nodes of every inode,
1352 * protected by inode_lock
1353 */
1354 struct radix_tree_root delayed_nodes_tree;
1355 /*
Chris Mason3394e162008-11-17 20:42:26 -05001356 * right now this just gets used so that a root has its own devid
1357 * for stat. It may be used for more later
1358 */
Al Viro0ee5dc62011-07-07 15:44:25 -04001359 dev_t anon_dev;
Liu Bof1ebcc72011-11-14 20:48:06 -05001360
1361 int force_cow;
Chris Mason62e27492007-03-15 12:56:47 -04001362};
1363
Chris Mason4cb53002011-05-24 15:35:30 -04001364struct btrfs_ioctl_defrag_range_args {
1365 /* start of the defrag operation */
1366 __u64 start;
1367
1368 /* number of bytes to defrag, use (u64)-1 to say all */
1369 __u64 len;
1370
1371 /*
1372 * flags for the operation, which can include turning
1373 * on compression for this one defrag
1374 */
1375 __u64 flags;
1376
1377 /*
1378 * any extent bigger than this will be considered
1379 * already defragged. Use 0 to take the kernel default
1380 * Use 1 to say every single extent must be rewritten
1381 */
1382 __u32 extent_thresh;
1383
1384 /*
1385 * which compression method to use if turning on compression
1386 * for this defrag operation. If unspecified, zlib will
1387 * be used
1388 */
1389 __u32 compress_type;
1390
1391 /* spare for later */
1392 __u32 unused[4];
1393};
1394
1395
Chris Mason1e1d2702007-03-15 19:03:33 -04001396/*
1397 * inode items have the data typically returned from stat and store other
1398 * info about object characteristics. There is one for every file and dir in
1399 * the FS
1400 */
Chris Mason9078a3e2007-04-26 16:46:15 -04001401#define BTRFS_INODE_ITEM_KEY 1
Chris Mason0660b5a2008-11-17 20:37:39 -05001402#define BTRFS_INODE_REF_KEY 12
1403#define BTRFS_XATTR_ITEM_KEY 24
1404#define BTRFS_ORPHAN_ITEM_KEY 48
Chris Mason9078a3e2007-04-26 16:46:15 -04001405/* reserve 2-15 close to the inode for later flexibility */
Chris Mason1e1d2702007-03-15 19:03:33 -04001406
1407/*
1408 * dir items are the name -> inode pointers in a directory. There is one
1409 * for every name in a directory.
1410 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001411#define BTRFS_DIR_LOG_ITEM_KEY 60
1412#define BTRFS_DIR_LOG_INDEX_KEY 72
1413#define BTRFS_DIR_ITEM_KEY 84
1414#define BTRFS_DIR_INDEX_KEY 96
Chris Mason1e1d2702007-03-15 19:03:33 -04001415/*
Chris Mason9078a3e2007-04-26 16:46:15 -04001416 * extent data is for file data
Chris Mason1e1d2702007-03-15 19:03:33 -04001417 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001418#define BTRFS_EXTENT_DATA_KEY 108
Chris Masond20f7042008-12-08 16:58:54 -05001419
Chris Mason1e1d2702007-03-15 19:03:33 -04001420/*
Chris Masond20f7042008-12-08 16:58:54 -05001421 * extent csums are stored in a separate tree and hold csums for
1422 * an entire extent on disk.
Chris Masonf254e522007-03-29 15:15:27 -04001423 */
Chris Masond20f7042008-12-08 16:58:54 -05001424#define BTRFS_EXTENT_CSUM_KEY 128
Chris Masonf254e522007-03-29 15:15:27 -04001425
1426/*
Wu Fengguangd4a78942009-04-02 16:46:06 -04001427 * root items point to tree roots. They are typically in the root
Chris Mason1e1d2702007-03-15 19:03:33 -04001428 * tree used by the super block to find all the other trees
1429 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001430#define BTRFS_ROOT_ITEM_KEY 132
1431
1432/*
1433 * root backrefs tie subvols and snapshots to the directory entries that
1434 * reference them
1435 */
1436#define BTRFS_ROOT_BACKREF_KEY 144
1437
1438/*
1439 * root refs make a fast index for listing all of the snapshots and
1440 * subvolumes referenced by a given root. They point directly to the
1441 * directory item in the root that references the subvol
1442 */
1443#define BTRFS_ROOT_REF_KEY 156
1444
Chris Mason1e1d2702007-03-15 19:03:33 -04001445/*
1446 * extent items are in the extent map tree. These record which blocks
1447 * are used, and how many references there are to each block
1448 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001449#define BTRFS_EXTENT_ITEM_KEY 168
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001450
1451#define BTRFS_TREE_BLOCK_REF_KEY 176
1452
1453#define BTRFS_EXTENT_DATA_REF_KEY 178
1454
1455#define BTRFS_EXTENT_REF_V0_KEY 180
1456
1457#define BTRFS_SHARED_BLOCK_REF_KEY 182
1458
1459#define BTRFS_SHARED_DATA_REF_KEY 184
Chris Mason9078a3e2007-04-26 16:46:15 -04001460
1461/*
1462 * block groups give us hints into the extent allocation trees. Which
1463 * blocks are free etc etc
1464 */
Chris Mason0660b5a2008-11-17 20:37:39 -05001465#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
Chris Mason9f5fae22007-03-20 14:38:32 -04001466
Chris Mason0660b5a2008-11-17 20:37:39 -05001467#define BTRFS_DEV_EXTENT_KEY 204
1468#define BTRFS_DEV_ITEM_KEY 216
1469#define BTRFS_CHUNK_ITEM_KEY 228
Chris Mason0b86a832008-03-24 15:01:56 -04001470
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02001471#define BTRFS_BALANCE_ITEM_KEY 248
1472
Chris Mason9f5fae22007-03-20 14:38:32 -04001473/*
Chris Mason1e1d2702007-03-15 19:03:33 -04001474 * string items are for debugging. They just store a short string of
1475 * data in the FS
1476 */
Chris Mason9078a3e2007-04-26 16:46:15 -04001477#define BTRFS_STRING_ITEM_KEY 253
1478
David Sterba0942caa2011-06-28 15:10:37 +00001479/*
1480 * Flags for mount options.
1481 *
1482 * Note: don't forget to add new options to btrfs_show_options()
1483 */
Chris Mason21ad10c2008-01-09 09:23:21 -05001484#define BTRFS_MOUNT_NODATASUM (1 << 0)
1485#define BTRFS_MOUNT_NODATACOW (1 << 1)
1486#define BTRFS_MOUNT_NOBARRIER (1 << 2)
Chris Masone18e4802008-01-18 10:54:22 -05001487#define BTRFS_MOUNT_SSD (1 << 3)
Chris Masondfe25022008-05-13 13:46:40 -04001488#define BTRFS_MOUNT_DEGRADED (1 << 4)
Chris Masonc8b97812008-10-29 14:49:59 -04001489#define BTRFS_MOUNT_COMPRESS (1 << 5)
Sage Weil3a5e1402009-04-02 16:49:40 -04001490#define BTRFS_MOUNT_NOTREELOG (1 << 6)
Sage Weildccae992009-04-02 16:59:01 -04001491#define BTRFS_MOUNT_FLUSHONCOMMIT (1 << 7)
Chris Mason451d7582009-06-09 20:28:34 -04001492#define BTRFS_MOUNT_SSD_SPREAD (1 << 8)
Chris Masonc2898112009-06-10 09:51:32 -04001493#define BTRFS_MOUNT_NOSSD (1 << 9)
Christoph Hellwige244a0a2009-10-14 09:24:59 -04001494#define BTRFS_MOUNT_DISCARD (1 << 10)
Chris Masona555f812010-01-28 16:18:15 -05001495#define BTRFS_MOUNT_FORCE_COMPRESS (1 << 11)
Josef Bacik0af3d002010-06-21 14:48:16 -04001496#define BTRFS_MOUNT_SPACE_CACHE (1 << 12)
Josef Bacik88c2ba32010-09-21 14:21:34 -04001497#define BTRFS_MOUNT_CLEAR_CACHE (1 << 13)
Sage Weil4260f7c2010-10-29 15:46:43 -04001498#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
Chris Mason91435652011-02-16 13:10:41 -05001499#define BTRFS_MOUNT_ENOSPC_DEBUG (1 << 15)
Chris Mason4cb53002011-05-24 15:35:30 -04001500#define BTRFS_MOUNT_AUTO_DEFRAG (1 << 16)
Chris Mason4b9465c2011-06-03 09:36:29 -04001501#define BTRFS_MOUNT_INODE_MAP_CACHE (1 << 17)
Chris Masonaf31f5e2011-11-03 15:17:42 -04001502#define BTRFS_MOUNT_RECOVERY (1 << 18)
Ilya Dryomov9555c6c2012-01-16 22:04:48 +02001503#define BTRFS_MOUNT_SKIP_BALANCE (1 << 19)
Chris Masonc126dea2012-01-16 15:27:58 -05001504#define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20)
1505#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
Chris Masonb6cda9b2007-12-14 15:30:32 -05001506
1507#define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt)
1508#define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt)
1509#define btrfs_test_opt(root, opt) ((root)->fs_info->mount_opt & \
1510 BTRFS_MOUNT_##opt)
Yanb98b6762008-01-08 15:54:37 -05001511/*
1512 * Inode flags
1513 */
Yanfdebe2b2008-01-14 13:26:08 -05001514#define BTRFS_INODE_NODATASUM (1 << 0)
1515#define BTRFS_INODE_NODATACOW (1 << 1)
1516#define BTRFS_INODE_READONLY (1 << 2)
Chris Masonc8b97812008-10-29 14:49:59 -04001517#define BTRFS_INODE_NOCOMPRESS (1 << 3)
Yan Zhengd899e052008-10-30 14:25:28 -04001518#define BTRFS_INODE_PREALLOC (1 << 4)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02001519#define BTRFS_INODE_SYNC (1 << 5)
1520#define BTRFS_INODE_IMMUTABLE (1 << 6)
1521#define BTRFS_INODE_APPEND (1 << 7)
1522#define BTRFS_INODE_NODUMP (1 << 8)
1523#define BTRFS_INODE_NOATIME (1 << 9)
1524#define BTRFS_INODE_DIRSYNC (1 << 10)
Liu Bo75e7cb72011-03-22 10:12:20 +00001525#define BTRFS_INODE_COMPRESS (1 << 11)
Christoph Hellwig6cbff002009-04-17 10:37:41 +02001526
Li Zefan08fe4db2011-03-28 02:01:25 +00001527#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31)
1528
Chris Mason5f39d392007-10-15 16:14:19 -04001529/* some macros to generate set/get funcs for the struct fields. This
1530 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1531 * one for u8:
1532 */
1533#define le8_to_cpu(v) (v)
1534#define cpu_to_le8(v) (v)
1535#define __le8 u8
Chris Mason9078a3e2007-04-26 16:46:15 -04001536
Chris Mason5f39d392007-10-15 16:14:19 -04001537#define read_eb_member(eb, ptr, type, member, result) ( \
1538 read_extent_buffer(eb, (char *)(result), \
1539 ((unsigned long)(ptr)) + \
1540 offsetof(type, member), \
1541 sizeof(((type *)0)->member)))
1542
1543#define write_eb_member(eb, ptr, type, member, result) ( \
1544 write_extent_buffer(eb, (char *)(result), \
1545 ((unsigned long)(ptr)) + \
1546 offsetof(type, member), \
1547 sizeof(((type *)0)->member)))
1548
Chris Mason0f827312007-10-15 16:18:56 -04001549#ifndef BTRFS_SETGET_FUNCS
Chris Mason5f39d392007-10-15 16:14:19 -04001550#define BTRFS_SETGET_FUNCS(name, type, member, bits) \
Chris Mason0f827312007-10-15 16:18:56 -04001551u##bits btrfs_##name(struct extent_buffer *eb, type *s); \
1552void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
1553#endif
Chris Mason9078a3e2007-04-26 16:46:15 -04001554
Chris Mason5f39d392007-10-15 16:14:19 -04001555#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
1556static inline u##bits btrfs_##name(struct extent_buffer *eb) \
1557{ \
Li Zefanc97c2912011-08-03 08:11:41 +00001558 type *p = page_address(eb->first_page); \
David Millerdf68b8a2008-02-15 10:40:52 -05001559 u##bits res = le##bits##_to_cpu(p->member); \
Chris Mason810191f2007-10-15 16:18:55 -04001560 return res; \
Chris Mason5f39d392007-10-15 16:14:19 -04001561} \
1562static inline void btrfs_set_##name(struct extent_buffer *eb, \
1563 u##bits val) \
1564{ \
Li Zefanc97c2912011-08-03 08:11:41 +00001565 type *p = page_address(eb->first_page); \
David Millerdf68b8a2008-02-15 10:40:52 -05001566 p->member = cpu_to_le##bits(val); \
Chris Mason9078a3e2007-04-26 16:46:15 -04001567}
Chris Mason1e1d2702007-03-15 19:03:33 -04001568
Chris Mason5f39d392007-10-15 16:14:19 -04001569#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits) \
1570static inline u##bits btrfs_##name(type *s) \
1571{ \
1572 return le##bits##_to_cpu(s->member); \
1573} \
1574static inline void btrfs_set_##name(type *s, u##bits val) \
1575{ \
1576 s->member = cpu_to_le##bits(val); \
Chris Mason1e1d2702007-03-15 19:03:33 -04001577}
1578
Chris Mason0b86a832008-03-24 15:01:56 -04001579BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1580BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
1581BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1582BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1583BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
Chris Masonc3027eb2008-12-08 16:40:21 -05001584BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1585 start_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001586BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1587BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001588BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1589BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1590BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05001591BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001592
Chris Mason8a4b83c2008-03-24 15:02:07 -04001593BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1594BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1595 total_bytes, 64);
1596BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1597 bytes_used, 64);
1598BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1599 io_align, 32);
1600BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1601 io_width, 32);
1602BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1603 sector_size, 32);
1604BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001605BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1606 dev_group, 32);
1607BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1608 seek_speed, 8);
1609BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1610 bandwidth, 8);
Yan Zheng2b820322008-11-17 21:11:30 -05001611BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1612 generation, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04001613
Chris Mason0b86a832008-03-24 15:01:56 -04001614static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
1615{
1616 return (char *)d + offsetof(struct btrfs_dev_item, uuid);
1617}
1618
Yan Zheng2b820322008-11-17 21:11:30 -05001619static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
1620{
1621 return (char *)d + offsetof(struct btrfs_dev_item, fsid);
1622}
1623
Chris Masone17cade2008-04-15 15:41:47 -04001624BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001625BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1626BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1627BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1628BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1629BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1630BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1631BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04001632BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04001633BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1634BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1635
Chris Masone17cade2008-04-15 15:41:47 -04001636static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1637{
1638 return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1639}
1640
1641BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001642BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1643BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1644 stripe_len, 64);
1645BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1646 io_align, 32);
1647BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1648 io_width, 32);
1649BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1650 sector_size, 32);
1651BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1652BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1653 num_stripes, 16);
Chris Mason321aecc2008-04-16 10:49:51 -04001654BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1655 sub_stripes, 16);
Chris Mason0b86a832008-03-24 15:01:56 -04001656BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1657BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1658
1659static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1660 int nr)
1661{
1662 unsigned long offset = (unsigned long)c;
1663 offset += offsetof(struct btrfs_chunk, stripe);
1664 offset += nr * sizeof(struct btrfs_stripe);
1665 return (struct btrfs_stripe *)offset;
1666}
1667
Chris Masona4437552008-04-18 10:29:38 -04001668static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1669{
1670 return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1671}
1672
Chris Mason0b86a832008-03-24 15:01:56 -04001673static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
1674 struct btrfs_chunk *c, int nr)
1675{
1676 return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1677}
1678
Chris Mason0b86a832008-03-24 15:01:56 -04001679static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
1680 struct btrfs_chunk *c, int nr)
1681{
1682 return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1683}
1684
Chris Mason5f39d392007-10-15 16:14:19 -04001685/* struct btrfs_block_group_item */
1686BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1687 used, 64);
1688BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1689 used, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001690BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1691 struct btrfs_block_group_item, chunk_objectid, 64);
Chris Masone17cade2008-04-15 15:41:47 -04001692
1693BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
Chris Mason0b86a832008-03-24 15:01:56 -04001694 struct btrfs_block_group_item, chunk_objectid, 64);
1695BTRFS_SETGET_FUNCS(disk_block_group_flags,
1696 struct btrfs_block_group_item, flags, 64);
1697BTRFS_SETGET_STACK_FUNCS(block_group_flags,
1698 struct btrfs_block_group_item, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001699
Chris Mason39544012007-12-12 14:38:19 -05001700/* struct btrfs_inode_ref */
1701BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
Josef Bacikaec74772008-07-24 12:12:38 -04001702BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
Chris Mason39544012007-12-12 14:38:19 -05001703
Chris Mason5f39d392007-10-15 16:14:19 -04001704/* struct btrfs_inode_item */
1705BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05001706BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
Chris Masone02119d2008-09-05 16:13:11 -04001707BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001708BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
Yan Zhenga76a3cd2008-10-09 11:46:29 -04001709BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001710BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1711BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1712BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1713BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1714BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
Chris Mason0b86a832008-03-24 15:01:56 -04001715BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05001716BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001717
Chris Mason0b86a832008-03-24 15:01:56 -04001718static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04001719btrfs_inode_atime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04001720{
Chris Mason5f39d392007-10-15 16:14:19 -04001721 unsigned long ptr = (unsigned long)inode_item;
1722 ptr += offsetof(struct btrfs_inode_item, atime);
Chris Mason0b86a832008-03-24 15:01:56 -04001723 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04001724}
1725
Chris Mason0b86a832008-03-24 15:01:56 -04001726static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04001727btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04001728{
Chris Mason5f39d392007-10-15 16:14:19 -04001729 unsigned long ptr = (unsigned long)inode_item;
1730 ptr += offsetof(struct btrfs_inode_item, mtime);
Chris Mason0b86a832008-03-24 15:01:56 -04001731 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04001732}
1733
Chris Mason0b86a832008-03-24 15:01:56 -04001734static inline struct btrfs_timespec *
Chris Mason5f39d392007-10-15 16:14:19 -04001735btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
Chris Mason1e1d2702007-03-15 19:03:33 -04001736{
Chris Mason5f39d392007-10-15 16:14:19 -04001737 unsigned long ptr = (unsigned long)inode_item;
1738 ptr += offsetof(struct btrfs_inode_item, ctime);
Chris Mason0b86a832008-03-24 15:01:56 -04001739 return (struct btrfs_timespec *)ptr;
Chris Mason1e1d2702007-03-15 19:03:33 -04001740}
1741
Chris Mason0b86a832008-03-24 15:01:56 -04001742BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1743BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001744
Chris Mason0b86a832008-03-24 15:01:56 -04001745/* struct btrfs_dev_extent */
Chris Masone17cade2008-04-15 15:41:47 -04001746BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1747 chunk_tree, 64);
1748BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1749 chunk_objectid, 64);
1750BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1751 chunk_offset, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04001752BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1753
Chris Masone17cade2008-04-15 15:41:47 -04001754static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1755{
1756 unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1757 return (u8 *)((unsigned long)dev + ptr);
1758}
1759
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001760BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1761BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1762 generation, 64);
1763BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
Chris Mason74493f72007-12-11 09:25:06 -05001764
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001765BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001766
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001767
1768BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1769
1770static inline void btrfs_tree_block_key(struct extent_buffer *eb,
1771 struct btrfs_tree_block_info *item,
1772 struct btrfs_disk_key *key)
1773{
1774 read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1775}
1776
1777static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
1778 struct btrfs_tree_block_info *item,
1779 struct btrfs_disk_key *key)
1780{
1781 write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1782}
1783
1784BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1785 root, 64);
1786BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1787 objectid, 64);
1788BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1789 offset, 64);
1790BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1791 count, 32);
1792
1793BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1794 count, 32);
1795
1796BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1797 type, 8);
1798BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1799 offset, 64);
1800
1801static inline u32 btrfs_extent_inline_ref_size(int type)
1802{
1803 if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1804 type == BTRFS_SHARED_BLOCK_REF_KEY)
1805 return sizeof(struct btrfs_extent_inline_ref);
1806 if (type == BTRFS_SHARED_DATA_REF_KEY)
1807 return sizeof(struct btrfs_shared_data_ref) +
1808 sizeof(struct btrfs_extent_inline_ref);
1809 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1810 return sizeof(struct btrfs_extent_data_ref) +
1811 offsetof(struct btrfs_extent_inline_ref, offset);
1812 BUG();
1813 return 0;
1814}
1815
1816BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1817BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1818 generation, 64);
1819BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1820BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04001821
1822/* struct btrfs_node */
1823BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
Chris Mason74493f72007-12-11 09:25:06 -05001824BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001825
1826static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001827{
Chris Mason5f39d392007-10-15 16:14:19 -04001828 unsigned long ptr;
1829 ptr = offsetof(struct btrfs_node, ptrs) +
1830 sizeof(struct btrfs_key_ptr) * nr;
1831 return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
Chris Mason1e1d2702007-03-15 19:03:33 -04001832}
1833
Chris Mason5f39d392007-10-15 16:14:19 -04001834static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
1835 int nr, u64 val)
Chris Mason31f3c992007-04-30 15:25:45 -04001836{
Chris Mason5f39d392007-10-15 16:14:19 -04001837 unsigned long ptr;
1838 ptr = offsetof(struct btrfs_node, ptrs) +
1839 sizeof(struct btrfs_key_ptr) * nr;
1840 btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
Chris Mason31f3c992007-04-30 15:25:45 -04001841}
1842
Chris Mason74493f72007-12-11 09:25:06 -05001843static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
1844{
1845 unsigned long ptr;
1846 ptr = offsetof(struct btrfs_node, ptrs) +
1847 sizeof(struct btrfs_key_ptr) * nr;
1848 return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1849}
1850
1851static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
1852 int nr, u64 val)
1853{
1854 unsigned long ptr;
1855 ptr = offsetof(struct btrfs_node, ptrs) +
1856 sizeof(struct btrfs_key_ptr) * nr;
1857 btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1858}
1859
Chris Mason810191f2007-10-15 16:18:55 -04001860static inline unsigned long btrfs_node_key_ptr_offset(int nr)
Chris Mason31f3c992007-04-30 15:25:45 -04001861{
Chris Mason5f39d392007-10-15 16:14:19 -04001862 return offsetof(struct btrfs_node, ptrs) +
1863 sizeof(struct btrfs_key_ptr) * nr;
Chris Mason31f3c992007-04-30 15:25:45 -04001864}
1865
Chris Masone644d022007-11-06 15:09:29 -05001866void btrfs_node_key(struct extent_buffer *eb,
1867 struct btrfs_disk_key *disk_key, int nr);
1868
Chris Mason5f39d392007-10-15 16:14:19 -04001869static inline void btrfs_set_node_key(struct extent_buffer *eb,
1870 struct btrfs_disk_key *disk_key, int nr)
1871{
1872 unsigned long ptr;
1873 ptr = btrfs_node_key_ptr_offset(nr);
1874 write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
1875 struct btrfs_key_ptr, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001876}
1877
Chris Mason5f39d392007-10-15 16:14:19 -04001878/* struct btrfs_item */
1879BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1880BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1881
1882static inline unsigned long btrfs_item_nr_offset(int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001883{
Chris Mason5f39d392007-10-15 16:14:19 -04001884 return offsetof(struct btrfs_leaf, items) +
1885 sizeof(struct btrfs_item) * nr;
Chris Mason1e1d2702007-03-15 19:03:33 -04001886}
1887
Chris Mason5f39d392007-10-15 16:14:19 -04001888static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
1889 int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001890{
Chris Mason5f39d392007-10-15 16:14:19 -04001891 return (struct btrfs_item *)btrfs_item_nr_offset(nr);
Chris Mason1e1d2702007-03-15 19:03:33 -04001892}
1893
Chris Mason5f39d392007-10-15 16:14:19 -04001894static inline u32 btrfs_item_end(struct extent_buffer *eb,
1895 struct btrfs_item *item)
Chris Mason1e1d2702007-03-15 19:03:33 -04001896{
Chris Mason5f39d392007-10-15 16:14:19 -04001897 return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
Chris Mason1e1d2702007-03-15 19:03:33 -04001898}
1899
Chris Mason5f39d392007-10-15 16:14:19 -04001900static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001901{
Chris Mason5f39d392007-10-15 16:14:19 -04001902 return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001903}
1904
Chris Mason5f39d392007-10-15 16:14:19 -04001905static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001906{
Chris Mason5f39d392007-10-15 16:14:19 -04001907 return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001908}
1909
Chris Mason5f39d392007-10-15 16:14:19 -04001910static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001911{
Chris Mason5f39d392007-10-15 16:14:19 -04001912 return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
Chris Mason1e1d2702007-03-15 19:03:33 -04001913}
1914
Chris Mason5f39d392007-10-15 16:14:19 -04001915static inline void btrfs_item_key(struct extent_buffer *eb,
1916 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001917{
Chris Mason5f39d392007-10-15 16:14:19 -04001918 struct btrfs_item *item = btrfs_item_nr(eb, nr);
1919 read_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001920}
1921
Chris Mason5f39d392007-10-15 16:14:19 -04001922static inline void btrfs_set_item_key(struct extent_buffer *eb,
1923 struct btrfs_disk_key *disk_key, int nr)
Chris Mason1e1d2702007-03-15 19:03:33 -04001924{
Chris Mason5f39d392007-10-15 16:14:19 -04001925 struct btrfs_item *item = btrfs_item_nr(eb, nr);
1926 write_eb_member(eb, item, struct btrfs_item, key, disk_key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001927}
1928
Chris Masone02119d2008-09-05 16:13:11 -04001929BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1930
Chris Mason0660b5a2008-11-17 20:37:39 -05001931/*
1932 * struct btrfs_root_ref
1933 */
1934BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
1935BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
1936BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
1937
Chris Mason5f39d392007-10-15 16:14:19 -04001938/* struct btrfs_dir_item */
Josef Bacik5103e942007-11-16 11:45:54 -05001939BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
Chris Mason5f39d392007-10-15 16:14:19 -04001940BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
1941BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
Chris Masone02119d2008-09-05 16:13:11 -04001942BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04001943
1944static inline void btrfs_dir_item_key(struct extent_buffer *eb,
1945 struct btrfs_dir_item *item,
1946 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04001947{
Chris Mason5f39d392007-10-15 16:14:19 -04001948 read_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001949}
1950
Chris Mason5f39d392007-10-15 16:14:19 -04001951static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
1952 struct btrfs_dir_item *item,
1953 struct btrfs_disk_key *key)
Chris Mason1e1d2702007-03-15 19:03:33 -04001954{
Chris Mason5f39d392007-10-15 16:14:19 -04001955 write_eb_member(eb, item, struct btrfs_dir_item, location, key);
Chris Mason1e1d2702007-03-15 19:03:33 -04001956}
1957
Josef Bacik0af3d002010-06-21 14:48:16 -04001958BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
1959 num_entries, 64);
1960BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
1961 num_bitmaps, 64);
1962BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
1963 generation, 64);
1964
1965static inline void btrfs_free_space_key(struct extent_buffer *eb,
1966 struct btrfs_free_space_header *h,
1967 struct btrfs_disk_key *key)
1968{
1969 read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1970}
1971
1972static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
1973 struct btrfs_free_space_header *h,
1974 struct btrfs_disk_key *key)
1975{
1976 write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
1977}
1978
Chris Mason5f39d392007-10-15 16:14:19 -04001979/* struct btrfs_disk_key */
1980BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
1981 objectid, 64);
1982BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
1983BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
Chris Mason1d4f6402007-03-15 15:18:43 -04001984
Chris Masone2fa7222007-03-12 16:22:34 -04001985static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
1986 struct btrfs_disk_key *disk)
1987{
1988 cpu->offset = le64_to_cpu(disk->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04001989 cpu->type = disk->type;
Chris Masone2fa7222007-03-12 16:22:34 -04001990 cpu->objectid = le64_to_cpu(disk->objectid);
1991}
1992
1993static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
1994 struct btrfs_key *cpu)
1995{
1996 disk->offset = cpu_to_le64(cpu->offset);
Chris Mason5f39d392007-10-15 16:14:19 -04001997 disk->type = cpu->type;
Chris Masone2fa7222007-03-12 16:22:34 -04001998 disk->objectid = cpu_to_le64(cpu->objectid);
1999}
2000
Chris Mason5f39d392007-10-15 16:14:19 -04002001static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
2002 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04002003{
Chris Mason5f39d392007-10-15 16:14:19 -04002004 struct btrfs_disk_key disk_key;
2005 btrfs_node_key(eb, &disk_key, nr);
2006 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002007}
2008
Chris Mason5f39d392007-10-15 16:14:19 -04002009static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
2010 struct btrfs_key *key, int nr)
Chris Masone2fa7222007-03-12 16:22:34 -04002011{
Chris Mason5f39d392007-10-15 16:14:19 -04002012 struct btrfs_disk_key disk_key;
2013 btrfs_item_key(eb, &disk_key, nr);
2014 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002015}
2016
Chris Mason5f39d392007-10-15 16:14:19 -04002017static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
2018 struct btrfs_dir_item *item,
2019 struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04002020{
Chris Mason5f39d392007-10-15 16:14:19 -04002021 struct btrfs_disk_key disk_key;
2022 btrfs_dir_item_key(eb, item, &disk_key);
2023 btrfs_disk_key_to_cpu(key, &disk_key);
Chris Masone2fa7222007-03-12 16:22:34 -04002024}
2025
Chris Mason5f39d392007-10-15 16:14:19 -04002026
2027static inline u8 btrfs_key_type(struct btrfs_key *key)
Chris Masone2fa7222007-03-12 16:22:34 -04002028{
Chris Mason5f39d392007-10-15 16:14:19 -04002029 return key->type;
Chris Masone2fa7222007-03-12 16:22:34 -04002030}
2031
Chris Mason5f39d392007-10-15 16:14:19 -04002032static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
Chris Masone2fa7222007-03-12 16:22:34 -04002033{
Chris Mason5f39d392007-10-15 16:14:19 -04002034 key->type = val;
Chris Masone2fa7222007-03-12 16:22:34 -04002035}
2036
Chris Mason5f39d392007-10-15 16:14:19 -04002037/* struct btrfs_header */
Chris Masondb945352007-10-15 16:15:53 -04002038BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002039BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2040 generation, 64);
2041BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2042BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
Chris Mason63b10fc2008-04-01 11:21:32 -04002043BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002044BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2045
Chris Mason63b10fc2008-04-01 11:21:32 -04002046static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
2047{
2048 return (btrfs_header_flags(eb) & flag) == flag;
2049}
2050
2051static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2052{
2053 u64 flags = btrfs_header_flags(eb);
2054 btrfs_set_header_flags(eb, flags | flag);
2055 return (flags & flag) == flag;
2056}
2057
2058static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2059{
2060 u64 flags = btrfs_header_flags(eb);
2061 btrfs_set_header_flags(eb, flags & ~flag);
2062 return (flags & flag) == flag;
2063}
2064
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002065static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
2066{
2067 u64 flags = btrfs_header_flags(eb);
2068 return flags >> BTRFS_BACKREF_REV_SHIFT;
2069}
2070
2071static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2072 int rev)
2073{
2074 u64 flags = btrfs_header_flags(eb);
2075 flags &= ~BTRFS_BACKREF_REV_MASK;
2076 flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2077 btrfs_set_header_flags(eb, flags);
2078}
2079
Chris Mason5f39d392007-10-15 16:14:19 -04002080static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
Chris Masone2fa7222007-03-12 16:22:34 -04002081{
Chris Mason5f39d392007-10-15 16:14:19 -04002082 unsigned long ptr = offsetof(struct btrfs_header, fsid);
2083 return (u8 *)ptr;
Chris Masone2fa7222007-03-12 16:22:34 -04002084}
2085
Chris Masone17cade2008-04-15 15:41:47 -04002086static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
2087{
2088 unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);
2089 return (u8 *)ptr;
2090}
2091
Chris Mason5f39d392007-10-15 16:14:19 -04002092static inline int btrfs_is_leaf(struct extent_buffer *eb)
Chris Mason7518a232007-03-12 12:01:18 -04002093{
Chris Masond3977122009-01-05 21:25:51 -05002094 return btrfs_header_level(eb) == 0;
Chris Mason7518a232007-03-12 12:01:18 -04002095}
2096
Chris Mason5f39d392007-10-15 16:14:19 -04002097/* struct btrfs_root_item */
Yan Zheng84234f32008-10-29 14:49:05 -04002098BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2099 generation, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002100BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
Chris Masondb945352007-10-15 16:15:53 -04002101BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2102BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002103
Yan Zheng84234f32008-10-29 14:49:05 -04002104BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2105 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002106BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2107BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
Chris Mason5f39d392007-10-15 16:14:19 -04002108BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2109BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002110BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
Chris Masondb945352007-10-15 16:15:53 -04002111BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2112BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
Yan Zheng80ff3852008-10-30 14:20:02 -04002113BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2114 last_snapshot, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002115
Li Zefanb83cc962010-12-20 16:04:08 +08002116static inline bool btrfs_root_readonly(struct btrfs_root *root)
2117{
2118 return root->root_item.flags & BTRFS_ROOT_SUBVOL_RDONLY;
2119}
2120
Chris Masonaf31f5e2011-11-03 15:17:42 -04002121/* struct btrfs_root_backup */
2122BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2123 tree_root, 64);
2124BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2125 tree_root_gen, 64);
2126BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2127 tree_root_level, 8);
2128
2129BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2130 chunk_root, 64);
2131BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2132 chunk_root_gen, 64);
2133BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2134 chunk_root_level, 8);
2135
2136BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2137 extent_root, 64);
2138BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2139 extent_root_gen, 64);
2140BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2141 extent_root_level, 8);
2142
2143BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2144 fs_root, 64);
2145BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2146 fs_root_gen, 64);
2147BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2148 fs_root_level, 8);
2149
2150BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2151 dev_root, 64);
2152BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2153 dev_root_gen, 64);
2154BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2155 dev_root_level, 8);
2156
2157BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2158 csum_root, 64);
2159BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2160 csum_root_gen, 64);
2161BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2162 csum_root_level, 8);
2163BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2164 total_bytes, 64);
2165BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2166 bytes_used, 64);
2167BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2168 num_devices, 64);
2169
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002170/* struct btrfs_balance_item */
2171BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002172
Ilya Dryomov0940ebf2012-01-16 22:04:48 +02002173static inline void btrfs_balance_data(struct extent_buffer *eb,
2174 struct btrfs_balance_item *bi,
2175 struct btrfs_disk_balance_args *ba)
2176{
2177 read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2178}
2179
2180static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2181 struct btrfs_balance_item *bi,
2182 struct btrfs_disk_balance_args *ba)
2183{
2184 write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2185}
2186
2187static inline void btrfs_balance_meta(struct extent_buffer *eb,
2188 struct btrfs_balance_item *bi,
2189 struct btrfs_disk_balance_args *ba)
2190{
2191 read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2192}
2193
2194static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2195 struct btrfs_balance_item *bi,
2196 struct btrfs_disk_balance_args *ba)
2197{
2198 write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2199}
2200
2201static inline void btrfs_balance_sys(struct extent_buffer *eb,
2202 struct btrfs_balance_item *bi,
2203 struct btrfs_disk_balance_args *ba)
2204{
2205 read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2206}
2207
2208static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2209 struct btrfs_balance_item *bi,
2210 struct btrfs_disk_balance_args *ba)
2211{
2212 write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2213}
2214
2215static inline void
2216btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2217 struct btrfs_disk_balance_args *disk)
2218{
2219 memset(cpu, 0, sizeof(*cpu));
2220
2221 cpu->profiles = le64_to_cpu(disk->profiles);
2222 cpu->usage = le64_to_cpu(disk->usage);
2223 cpu->devid = le64_to_cpu(disk->devid);
2224 cpu->pstart = le64_to_cpu(disk->pstart);
2225 cpu->pend = le64_to_cpu(disk->pend);
2226 cpu->vstart = le64_to_cpu(disk->vstart);
2227 cpu->vend = le64_to_cpu(disk->vend);
2228 cpu->target = le64_to_cpu(disk->target);
2229 cpu->flags = le64_to_cpu(disk->flags);
2230}
2231
2232static inline void
2233btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2234 struct btrfs_balance_args *cpu)
2235{
2236 memset(disk, 0, sizeof(*disk));
2237
2238 disk->profiles = cpu_to_le64(cpu->profiles);
2239 disk->usage = cpu_to_le64(cpu->usage);
2240 disk->devid = cpu_to_le64(cpu->devid);
2241 disk->pstart = cpu_to_le64(cpu->pstart);
2242 disk->pend = cpu_to_le64(cpu->pend);
2243 disk->vstart = cpu_to_le64(cpu->vstart);
2244 disk->vend = cpu_to_le64(cpu->vend);
2245 disk->target = cpu_to_le64(cpu->target);
2246 disk->flags = cpu_to_le64(cpu->flags);
2247}
2248
2249/* struct btrfs_super_block */
Chris Masondb945352007-10-15 16:15:53 -04002250BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
Chris Masona061fc82008-05-07 11:43:44 -04002251BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002252BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2253 generation, 64);
2254BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
Chris Mason0b86a832008-03-24 15:01:56 -04002255BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2256 struct btrfs_super_block, sys_chunk_array_size, 32);
Yan Zheng84234f32008-10-29 14:49:05 -04002257BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2258 struct btrfs_super_block, chunk_root_generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002259BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2260 root_level, 8);
Chris Mason0b86a832008-03-24 15:01:56 -04002261BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2262 chunk_root, 64);
2263BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
Chris Masone02119d2008-09-05 16:13:11 -04002264 chunk_root_level, 8);
2265BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2266 log_root, 64);
Chris Masonc3027eb2008-12-08 16:40:21 -05002267BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2268 log_root_transid, 64);
Chris Masone02119d2008-09-05 16:13:11 -04002269BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2270 log_root_level, 8);
Chris Masondb945352007-10-15 16:15:53 -04002271BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2272 total_bytes, 64);
2273BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2274 bytes_used, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002275BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2276 sectorsize, 32);
2277BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2278 nodesize, 32);
2279BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
2280 leafsize, 32);
Chris Mason87ee04e2007-11-30 11:30:34 -05002281BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2282 stripesize, 32);
Chris Mason5f39d392007-10-15 16:14:19 -04002283BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2284 root_dir_objectid, 64);
Chris Mason8a4b83c2008-03-24 15:02:07 -04002285BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2286 num_devices, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002287BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2288 compat_flags, 64);
2289BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
Josef Bacik12534832009-12-17 21:32:27 +00002290 compat_ro_flags, 64);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002291BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2292 incompat_flags, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002293BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2294 csum_type, 16);
Josef Bacik0af3d002010-06-21 14:48:16 -04002295BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2296 cache_generation, 64);
Josef Bacik607d4322008-12-02 07:17:45 -05002297
2298static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
2299{
2300 int t = btrfs_super_csum_type(s);
2301 BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes));
2302 return btrfs_csum_sizes[t];
2303}
Chris Mason5f39d392007-10-15 16:14:19 -04002304
2305static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
Chris Mason7f5c1512007-03-23 15:56:19 -04002306{
Chris Mason5f39d392007-10-15 16:14:19 -04002307 return offsetof(struct btrfs_leaf, items);
Chris Mason7f5c1512007-03-23 15:56:19 -04002308}
2309
Chris Mason5f39d392007-10-15 16:14:19 -04002310/* struct btrfs_file_extent_item */
2311BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
Chris Mason7f5c1512007-03-23 15:56:19 -04002312
Chris Masond3977122009-01-05 21:25:51 -05002313static inline unsigned long
2314btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
Chris Mason236454df2007-04-19 13:37:44 -04002315{
Chris Mason5f39d392007-10-15 16:14:19 -04002316 unsigned long offset = (unsigned long)e;
Chris Masondb945352007-10-15 16:15:53 -04002317 offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
Chris Mason5f39d392007-10-15 16:14:19 -04002318 return offset;
Chris Mason236454df2007-04-19 13:37:44 -04002319}
2320
2321static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2322{
Chris Masondb945352007-10-15 16:15:53 -04002323 return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
Chris Mason236454df2007-04-19 13:37:44 -04002324}
2325
Chris Masondb945352007-10-15 16:15:53 -04002326BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2327 disk_bytenr, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002328BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2329 generation, 64);
Chris Masondb945352007-10-15 16:15:53 -04002330BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2331 disk_num_bytes, 64);
Chris Mason5f39d392007-10-15 16:14:19 -04002332BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2333 offset, 64);
Chris Masondb945352007-10-15 16:15:53 -04002334BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2335 num_bytes, 64);
Chris Masonc8b97812008-10-29 14:49:59 -04002336BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2337 ram_bytes, 64);
2338BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2339 compression, 8);
2340BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2341 encryption, 8);
2342BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2343 other_encoding, 16);
2344
2345/* this returns the number of file bytes represented by the inline item.
2346 * If an item is compressed, this is the uncompressed size
2347 */
2348static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
2349 struct btrfs_file_extent_item *e)
2350{
2351 return btrfs_file_extent_ram_bytes(eb, e);
2352}
2353
2354/*
2355 * this returns the number of bytes used by the item on disk, minus the
2356 * size of any extent headers. If a file is compressed on disk, this is
2357 * the compressed size
2358 */
2359static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
2360 struct btrfs_item *e)
2361{
2362 unsigned long offset;
2363 offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
2364 return btrfs_item_size(eb, e) - offset;
2365}
Chris Mason9f5fae22007-03-20 14:38:32 -04002366
Al Viro815745c2011-11-17 15:40:49 -05002367static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
Chris Masone20d96d2007-03-22 12:13:20 -04002368{
2369 return sb->s_fs_info;
2370}
2371
Chris Masond3977122009-01-05 21:25:51 -05002372static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
2373{
Chris Masondb945352007-10-15 16:15:53 -04002374 if (level == 0)
2375 return root->leafsize;
2376 return root->nodesize;
2377}
2378
Chris Mason4beb1b82007-03-14 10:31:29 -04002379/* helper function to cast into the data area of the leaf. */
2380#define btrfs_item_ptr(leaf, slot, type) \
Chris Mason123abc82007-03-14 14:14:43 -04002381 ((type *)(btrfs_leaf_data(leaf) + \
Chris Mason5f39d392007-10-15 16:14:19 -04002382 btrfs_item_offset_nr(leaf, slot)))
2383
2384#define btrfs_item_ptr_offset(leaf, slot) \
2385 ((unsigned long)(btrfs_leaf_data(leaf) + \
2386 btrfs_item_offset_nr(leaf, slot)))
Chris Mason4beb1b82007-03-14 10:31:29 -04002387
Chris Mason2b1f55b2008-09-24 11:48:04 -04002388static inline struct dentry *fdentry(struct file *file)
2389{
Chris Mason6da6aba2007-12-18 16:15:09 -05002390 return file->f_path.dentry;
Chris Mason6da6aba2007-12-18 16:15:09 -05002391}
2392
Josef Bacik67377732010-09-16 16:19:09 -04002393static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
2394{
2395 return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
2396 (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
2397}
2398
Josef Bacik3b16a4e2011-09-21 15:05:58 -04002399static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2400{
2401 return mapping_gfp_mask(mapping) & ~__GFP_FS;
2402}
2403
Chris Masonb18c6682007-04-17 13:26:50 -04002404/* extent-tree.c */
Miao Xie16cdcec2011-04-22 18:12:22 +08002405static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
Josef Bacik9e0baf62011-07-15 15:16:44 +00002406 unsigned num_items)
Miao Xie16cdcec2011-04-22 18:12:22 +08002407{
2408 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
2409 3 * num_items;
2410}
2411
Josef Bacik07127182011-08-19 10:29:59 -04002412/*
2413 * Doing a truncate won't result in new nodes or leaves, just what we need for
2414 * COW.
2415 */
2416static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
2417 unsigned num_items)
2418{
2419 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
2420 num_items;
2421}
2422
Chris Masonfa9c0d792009-04-03 09:47:43 -04002423void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Chris Mason56bec292009-03-13 10:10:06 -04002424int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2425 struct btrfs_root *root, unsigned long count);
Zheng Yan31840ae2008-09-23 13:14:14 -04002426int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002427int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2428 struct btrfs_root *root, u64 bytenr,
2429 u64 num_bytes, u64 *refs, u64 *flags);
Yan Zheng11833d62009-09-11 16:11:19 -04002430int btrfs_pin_extent(struct btrfs_root *root,
2431 u64 bytenr, u64 num, int reserved);
Chris Masone688b7252011-10-31 20:52:39 -04002432int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2433 struct btrfs_root *root,
2434 u64 bytenr, u64 num_bytes);
Yan Zheng80ff3852008-10-30 14:20:02 -04002435int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002436 struct btrfs_root *root,
2437 u64 objectid, u64 offset, u64 bytenr);
Chris Masond3977122009-01-05 21:25:51 -05002438struct btrfs_block_group_cache *btrfs_lookup_block_group(
2439 struct btrfs_fs_info *info,
2440 u64 bytenr);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002441void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
Yan Zhengd2fb3432008-12-11 16:30:39 -05002442u64 btrfs_find_block_group(struct btrfs_root *root,
2443 u64 search_start, u64 search_hint, int owner);
Chris Mason5f39d392007-10-15 16:14:19 -04002444struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002445 struct btrfs_root *root, u32 blocksize,
2446 u64 parent, u64 root_objectid,
2447 struct btrfs_disk_key *key, int level,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002448 u64 hint, u64 empty_size, int for_cow);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002449void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2450 struct btrfs_root *root,
2451 struct extent_buffer *buf,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002452 u64 parent, int last_ref, int for_cow);
Chris Mason65b51a02008-08-01 15:11:20 -04002453struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
2454 struct btrfs_root *root,
Chris Mason4008c042009-02-12 14:09:45 -05002455 u64 bytenr, u32 blocksize,
2456 int level);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002457int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
2458 struct btrfs_root *root,
2459 u64 root_objectid, u64 owner,
2460 u64 offset, struct btrfs_key *ins);
2461int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2462 struct btrfs_root *root,
2463 u64 root_objectid, u64 owner, u64 offset,
2464 struct btrfs_key *ins);
Chris Masone6dcd2d2008-07-17 12:53:50 -04002465int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
2466 struct btrfs_root *root,
2467 u64 num_bytes, u64 min_alloc_size,
2468 u64 empty_size, u64 hint_byte,
2469 u64 search_end, struct btrfs_key *ins,
2470 u64 data);
Chris Masone089f052007-03-16 16:20:31 -04002471int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002472 struct extent_buffer *buf, int full_backref, int for_cow);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002473int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002474 struct extent_buffer *buf, int full_backref, int for_cow);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002475int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2476 struct btrfs_root *root,
2477 u64 bytenr, u64 num_bytes, u64 flags,
2478 int is_data);
Zheng Yan31840ae2008-09-23 13:14:14 -04002479int btrfs_free_extent(struct btrfs_trans_handle *trans,
2480 struct btrfs_root *root,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002481 u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
2482 u64 owner, u64 offset, int for_cow);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002483
Chris Mason65b51a02008-08-01 15:11:20 -04002484int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
Chris Masone688b7252011-10-31 20:52:39 -04002485int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
2486 u64 start, u64 len);
Yan Zheng11833d62009-09-11 16:11:19 -04002487int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
2488 struct btrfs_root *root);
Chris Masonccd467d2007-06-28 15:57:36 -04002489int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
Yan Zheng11833d62009-09-11 16:11:19 -04002490 struct btrfs_root *root);
Chris Masonb18c6682007-04-17 13:26:50 -04002491int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Zheng Yan31840ae2008-09-23 13:14:14 -04002492 struct btrfs_root *root,
2493 u64 bytenr, u64 num_bytes, u64 parent,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002494 u64 root_objectid, u64 owner, u64 offset, int for_cow);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002495
Chris Mason9078a3e2007-04-26 16:46:15 -04002496int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2497 struct btrfs_root *root);
Yan Zhengd2fb3432008-12-11 16:30:39 -05002498int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
Chris Mason9078a3e2007-04-26 16:46:15 -04002499int btrfs_free_block_groups(struct btrfs_fs_info *info);
2500int btrfs_read_block_groups(struct btrfs_root *root);
Josef Bacikba1bf482009-09-11 16:11:19 -04002501int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
Chris Mason0b86a832008-03-24 15:01:56 -04002502int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2503 struct btrfs_root *root, u64 bytes_used,
Chris Masone17cade2008-04-15 15:41:47 -04002504 u64 type, u64 chunk_objectid, u64 chunk_offset,
Chris Mason0b86a832008-03-24 15:01:56 -04002505 u64 size);
Zheng Yan1a40e232008-09-26 10:09:34 -04002506int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2507 struct btrfs_root *root, u64 group_start);
Yan Zheng2b820322008-11-17 21:11:30 -05002508u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
Miao Xie6d07bce2011-01-05 10:07:31 +00002509u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
Josef Bacik6a632092009-02-20 11:00:09 -05002510void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde);
Chris Mason4184ea72009-03-10 12:39:20 -04002511void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002512int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
2513void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002514void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
2515 struct btrfs_root *root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04002516int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
2517 struct inode *inode);
2518void btrfs_orphan_release_metadata(struct inode *inode);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002519int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
2520 struct btrfs_pending_snapshot *pending);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002521int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
2522void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
2523int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
2524void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002525void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv);
2526struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root);
2527void btrfs_free_block_rsv(struct btrfs_root *root,
2528 struct btrfs_block_rsv *rsv);
Josef Bacik4a92b1b2011-08-30 12:34:28 -04002529int btrfs_block_rsv_add(struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002530 struct btrfs_block_rsv *block_rsv,
Josef Bacik8bb8ab22010-10-15 16:52:49 -04002531 u64 num_bytes);
Josef Bacikc06a0e12011-11-04 19:56:02 -04002532int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
2533 struct btrfs_block_rsv *block_rsv,
2534 u64 num_bytes);
Josef Bacik4a92b1b2011-08-30 12:34:28 -04002535int btrfs_block_rsv_check(struct btrfs_root *root,
Josef Bacik36ba0222011-10-18 12:15:48 -04002536 struct btrfs_block_rsv *block_rsv, int min_factor);
2537int btrfs_block_rsv_refill(struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002538 struct btrfs_block_rsv *block_rsv,
Josef Bacik36ba0222011-10-18 12:15:48 -04002539 u64 min_reserved);
Miao Xieaa38a712011-11-18 17:43:00 +08002540int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
2541 struct btrfs_block_rsv *block_rsv,
2542 u64 min_reserved);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002543int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
2544 struct btrfs_block_rsv *dst_rsv,
2545 u64 num_bytes);
2546void btrfs_block_rsv_release(struct btrfs_root *root,
2547 struct btrfs_block_rsv *block_rsv,
2548 u64 num_bytes);
2549int btrfs_set_block_group_ro(struct btrfs_root *root,
2550 struct btrfs_block_group_cache *cache);
2551int btrfs_set_block_group_rw(struct btrfs_root *root,
2552 struct btrfs_block_group_cache *cache);
Josef Bacik0af3d002010-06-21 14:48:16 -04002553void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
Miao Xie6d07bce2011-01-05 10:07:31 +00002554u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
liuboacce9522011-01-06 19:30:25 +08002555int btrfs_error_unpin_extent_range(struct btrfs_root *root,
2556 u64 start, u64 end);
2557int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
Li Dongyang5378e602011-03-24 10:24:27 +00002558 u64 num_bytes, u64 *actual_bytes);
Chris Masonc87f08c2011-02-16 13:57:04 -05002559int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
2560 struct btrfs_root *root, u64 type);
Li Dongyangf7039b12011-03-24 10:24:28 +00002561int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
liuboacce9522011-01-06 19:30:25 +08002562
liuboc59021f2011-03-07 02:13:14 +00002563int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
Chris Masondee26a92007-03-26 16:00:06 -04002564/* ctree.c */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002565int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
2566 int level, int *slot);
2567int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
Chris Mason0b86a832008-03-24 15:01:56 -04002568int btrfs_previous_item(struct btrfs_root *root,
2569 struct btrfs_path *path, u64 min_objectid,
2570 int type);
Zheng Yan31840ae2008-09-23 13:14:14 -04002571int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
2572 struct btrfs_root *root, struct btrfs_path *path,
2573 struct btrfs_key *new_key);
Chris Mason925baed2008-06-25 16:01:30 -04002574struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2575struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
Chris Masone7a84562008-06-25 16:01:31 -04002576int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
Chris Mason3f157a22008-06-25 16:01:31 -04002577 struct btrfs_key *key, int lowest_level,
2578 int cache_only, u64 min_trans);
2579int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
Chris Masone02119d2008-09-05 16:13:11 -04002580 struct btrfs_key *max_key,
Chris Mason3f157a22008-06-25 16:01:31 -04002581 struct btrfs_path *path, int cache_only,
2582 u64 min_trans);
Chris Mason5f39d392007-10-15 16:14:19 -04002583int btrfs_cow_block(struct btrfs_trans_handle *trans,
2584 struct btrfs_root *root, struct extent_buffer *buf,
2585 struct extent_buffer *parent, int parent_slot,
Chris Mason9fa8cfe2009-03-13 10:24:59 -04002586 struct extent_buffer **cow_ret);
Chris Masonbe20aa92007-12-17 20:14:01 -05002587int btrfs_copy_root(struct btrfs_trans_handle *trans,
2588 struct btrfs_root *root,
2589 struct extent_buffer *buf,
2590 struct extent_buffer **cow_ret, u64 new_root_objectid);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002591int btrfs_block_can_be_shared(struct btrfs_root *root,
2592 struct extent_buffer *buf);
Chris Mason6567e832007-04-16 09:22:45 -04002593int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
2594 *root, struct btrfs_path *path, u32 data_size);
Chris Masonb18c6682007-04-17 13:26:50 -04002595int btrfs_truncate_item(struct btrfs_trans_handle *trans,
2596 struct btrfs_root *root,
2597 struct btrfs_path *path,
Chris Mason179e29e2007-11-01 11:28:41 -04002598 u32 new_size, int from_end);
Chris Mason459931e2008-12-10 09:10:46 -05002599int btrfs_split_item(struct btrfs_trans_handle *trans,
2600 struct btrfs_root *root,
2601 struct btrfs_path *path,
2602 struct btrfs_key *new_key,
2603 unsigned long split_offset);
Yan, Zhengad48fd752009-11-12 09:33:58 +00002604int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2605 struct btrfs_root *root,
2606 struct btrfs_path *path,
2607 struct btrfs_key *new_key);
Chris Masone089f052007-03-16 16:20:31 -04002608int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
2609 *root, struct btrfs_key *key, struct btrfs_path *p, int
2610 ins_len, int cow);
Chris Mason6702ed42007-08-07 16:15:09 -04002611int btrfs_realloc_node(struct btrfs_trans_handle *trans,
Chris Mason5f39d392007-10-15 16:14:19 -04002612 struct btrfs_root *root, struct extent_buffer *parent,
Chris Masona6b6e752007-10-15 16:22:39 -04002613 int start_slot, int cache_only, u64 *last_ret,
2614 struct btrfs_key *progress);
David Sterbab3b4aa72011-04-21 01:20:15 +02002615void btrfs_release_path(struct btrfs_path *p);
Chris Mason2c90e5d2007-04-02 10:50:19 -04002616struct btrfs_path *btrfs_alloc_path(void);
2617void btrfs_free_path(struct btrfs_path *p);
Chris Masonb4ce94d2009-02-04 09:25:08 -05002618void btrfs_set_path_blocking(struct btrfs_path *p);
Miao Xie16cdcec2011-04-22 18:12:22 +08002619void btrfs_clear_path_blocking(struct btrfs_path *p,
Chris Masonbd681512011-07-16 15:23:14 -04002620 struct extent_buffer *held, int held_rw);
Chris Masonb4ce94d2009-02-04 09:25:08 -05002621void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2622
Chris Mason85e21ba2008-01-29 15:11:36 -05002623int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2624 struct btrfs_path *path, int slot, int nr);
Chris Mason85e21ba2008-01-29 15:11:36 -05002625static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2626 struct btrfs_root *root,
2627 struct btrfs_path *path)
2628{
2629 return btrfs_del_items(trans, root, path, path->slots[0], 1);
2630}
2631
Miao Xie16cdcec2011-04-22 18:12:22 +08002632int setup_items_for_insert(struct btrfs_trans_handle *trans,
2633 struct btrfs_root *root, struct btrfs_path *path,
2634 struct btrfs_key *cpu_key, u32 *data_size,
2635 u32 total_data, u32 total_size, int nr);
Chris Masone089f052007-03-16 16:20:31 -04002636int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
2637 *root, struct btrfs_key *key, void *data, u32 data_size);
Chris Mason9c583092008-01-29 15:15:18 -05002638int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
2639 struct btrfs_root *root,
2640 struct btrfs_path *path,
2641 struct btrfs_key *cpu_key, u32 *data_size, int nr);
2642
2643static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
2644 struct btrfs_root *root,
2645 struct btrfs_path *path,
2646 struct btrfs_key *key,
2647 u32 data_size)
2648{
2649 return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
2650}
2651
Chris Mason234b63a2007-03-13 10:46:10 -04002652int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
Jan Schmidtc7d22a32011-11-22 15:14:33 +01002653static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
2654{
2655 ++p->slots[0];
2656 if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
2657 return btrfs_next_leaf(root, p);
2658 return 0;
2659}
Chris Mason7bb86312007-12-11 09:25:06 -05002660int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
Chris Mason5f39d392007-10-15 16:14:19 -04002661int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
Tsutomu Itohcb1b69f2011-08-09 07:11:13 +00002662void btrfs_drop_snapshot(struct btrfs_root *root,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02002663 struct btrfs_block_rsv *block_rsv, int update_ref,
2664 int for_reloc);
Yan Zhengf82d02d2008-10-29 14:49:05 -04002665int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2666 struct btrfs_root *root,
2667 struct extent_buffer *node,
2668 struct extent_buffer *parent);
David Sterba7841cb22011-05-31 18:07:27 +02002669static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
2670{
2671 /*
2672 * Get synced with close_ctree()
2673 */
2674 smp_mb();
2675 return fs_info->closing;
2676}
David Sterba6c417612011-04-13 15:41:04 +02002677static inline void free_fs_info(struct btrfs_fs_info *fs_info)
2678{
Ilya Dryomov837d5b62012-01-16 22:04:49 +02002679 kfree(fs_info->balance_ctl);
David Sterba6c417612011-04-13 15:41:04 +02002680 kfree(fs_info->delayed_root);
2681 kfree(fs_info->extent_root);
2682 kfree(fs_info->tree_root);
2683 kfree(fs_info->chunk_root);
2684 kfree(fs_info->dev_root);
2685 kfree(fs_info->csum_root);
2686 kfree(fs_info->super_copy);
2687 kfree(fs_info->super_for_commit);
2688 kfree(fs_info);
2689}
Ilya Dryomov70922612012-01-16 22:04:48 +02002690/**
2691 * profile_is_valid - tests whether a given profile is valid and reduced
2692 * @flags: profile to validate
2693 * @extended: if true @flags is treated as an extended profile
2694 */
2695static inline int profile_is_valid(u64 flags, int extended)
2696{
2697 u64 mask = ~BTRFS_BLOCK_GROUP_PROFILE_MASK;
2698
2699 flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK;
2700 if (extended)
2701 mask &= ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
2702
2703 if (flags & mask)
2704 return 0;
2705 /* true if zero or exactly one bit set */
2706 return (flags & (~flags + 1)) == flags;
2707}
David Sterba7841cb22011-05-31 18:07:27 +02002708
Chris Masondee26a92007-03-26 16:00:06 -04002709/* root-item.c */
Chris Masonea9e8b12008-11-17 21:14:24 -05002710int btrfs_find_root_ref(struct btrfs_root *tree_root,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002711 struct btrfs_path *path,
2712 u64 root_id, u64 ref_id);
Chris Mason0660b5a2008-11-17 20:37:39 -05002713int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
2714 struct btrfs_root *tree_root,
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002715 u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
2716 const char *name, int name_len);
2717int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
2718 struct btrfs_root *tree_root,
2719 u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
Chris Mason0660b5a2008-11-17 20:37:39 -05002720 const char *name, int name_len);
Chris Masone089f052007-03-16 16:20:31 -04002721int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2722 struct btrfs_key *key);
2723int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
2724 *root, struct btrfs_key *key, struct btrfs_root_item
2725 *item);
2726int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
2727 *root, struct btrfs_key *key, struct btrfs_root_item
2728 *item);
2729int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
2730 btrfs_root_item *item, struct btrfs_key *key);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002731int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
Yan, Zheng76dda932009-09-21 16:00:26 -04002732int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
Mark Fashehbf5f32e2011-07-14 21:23:06 +00002733void btrfs_set_root_node(struct btrfs_root_item *item,
2734 struct extent_buffer *node);
Li Zefan08fe4db2011-03-28 02:01:25 +00002735void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
2736
Chris Masondee26a92007-03-26 16:00:06 -04002737/* dir-item.c */
Chris Masond3977122009-01-05 21:25:51 -05002738int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
2739 struct btrfs_root *root, const char *name,
Miao Xie16cdcec2011-04-22 18:12:22 +08002740 int name_len, struct inode *dir,
Josef Bacikaec74772008-07-24 12:12:38 -04002741 struct btrfs_key *location, u8 type, u64 index);
Chris Mason7e381802007-04-19 15:36:27 -04002742struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
2743 struct btrfs_root *root,
2744 struct btrfs_path *path, u64 dir,
2745 const char *name, int name_len,
2746 int mod);
2747struct btrfs_dir_item *
2748btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
2749 struct btrfs_root *root,
2750 struct btrfs_path *path, u64 dir,
2751 u64 objectid, const char *name, int name_len,
2752 int mod);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002753struct btrfs_dir_item *
2754btrfs_search_dir_index_item(struct btrfs_root *root,
2755 struct btrfs_path *path, u64 dirid,
2756 const char *name, int name_len);
Chris Mason7e381802007-04-19 15:36:27 -04002757struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
2758 struct btrfs_path *path,
Chris Mason7f5c1512007-03-23 15:56:19 -04002759 const char *name, int name_len);
Chris Mason7e381802007-04-19 15:36:27 -04002760int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
2761 struct btrfs_root *root,
2762 struct btrfs_path *path,
2763 struct btrfs_dir_item *di);
Josef Bacik5103e942007-11-16 11:45:54 -05002764int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
Yan, Zhengf34f57a2009-11-12 09:35:27 +00002765 struct btrfs_root *root,
2766 struct btrfs_path *path, u64 objectid,
2767 const char *name, u16 name_len,
2768 const void *data, u16 data_len);
Josef Bacik5103e942007-11-16 11:45:54 -05002769struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
2770 struct btrfs_root *root,
2771 struct btrfs_path *path, u64 dir,
2772 const char *name, u16 name_len,
2773 int mod);
Josef Bacik22a94d42011-03-16 16:47:17 -04002774int verify_dir_item(struct btrfs_root *root,
2775 struct extent_buffer *leaf,
2776 struct btrfs_dir_item *dir_item);
Josef Bacik7b128762008-07-24 12:17:14 -04002777
2778/* orphan.c */
2779int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
2780 struct btrfs_root *root, u64 offset);
2781int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
2782 struct btrfs_root *root, u64 offset);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002783int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
Josef Bacik7b128762008-07-24 12:17:14 -04002784
Chris Masondee26a92007-03-26 16:00:06 -04002785/* inode-item.c */
Chris Mason39544012007-12-12 14:38:19 -05002786int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
2787 struct btrfs_root *root,
2788 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04002789 u64 inode_objectid, u64 ref_objectid, u64 index);
Chris Mason39544012007-12-12 14:38:19 -05002790int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
2791 struct btrfs_root *root,
2792 const char *name, int name_len,
Josef Bacikaec74772008-07-24 12:12:38 -04002793 u64 inode_objectid, u64 ref_objectid, u64 *index);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002794struct btrfs_inode_ref *
2795btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
2796 struct btrfs_root *root,
2797 struct btrfs_path *path,
2798 const char *name, int name_len,
2799 u64 inode_objectid, u64 ref_objectid, int mod);
Chris Mason5f39d392007-10-15 16:14:19 -04002800int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
2801 struct btrfs_root *root,
2802 struct btrfs_path *path, u64 objectid);
Chris Mason293ffd52007-03-20 15:57:25 -04002803int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
Chris Masond6e4a422007-04-06 15:37:36 -04002804 *root, struct btrfs_path *path,
2805 struct btrfs_key *location, int mod);
Chris Masondee26a92007-03-26 16:00:06 -04002806
2807/* file-item.c */
Chris Mason459931e2008-12-10 09:10:46 -05002808int btrfs_del_csums(struct btrfs_trans_handle *trans,
2809 struct btrfs_root *root, u64 bytenr, u64 len);
Chris Mason61b49442008-07-31 15:42:53 -04002810int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
Chris Masond20f7042008-12-08 16:58:54 -05002811 struct bio *bio, u32 *dst);
Josef Bacik4b46fce2010-05-23 11:00:55 -04002812int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
2813 struct bio *bio, u64 logical_offset, u32 *dst);
Chris Masonb18c6682007-04-17 13:26:50 -04002814int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
Chris Masonc8b97812008-10-29 14:49:59 -04002815 struct btrfs_root *root,
2816 u64 objectid, u64 pos,
2817 u64 disk_offset, u64 disk_num_bytes,
2818 u64 num_bytes, u64 offset, u64 ram_bytes,
2819 u8 compression, u8 encryption, u16 other_encoding);
Chris Masondee26a92007-03-26 16:00:06 -04002820int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
2821 struct btrfs_root *root,
2822 struct btrfs_path *path, u64 objectid,
Chris Masondb945352007-10-15 16:15:53 -04002823 u64 bytenr, int mod);
Chris Mason065631f2008-02-20 12:07:25 -05002824int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
Chris Masond20f7042008-12-08 16:58:54 -05002825 struct btrfs_root *root,
Chris Masone6dcd2d2008-07-17 12:53:50 -04002826 struct btrfs_ordered_sum *sums);
Chris Mason3edf7d32008-07-18 06:17:13 -04002827int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
Chris Masond20f7042008-12-08 16:58:54 -05002828 struct bio *bio, u64 file_start, int contig);
Chris Masonb18c6682007-04-17 13:26:50 -04002829struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
2830 struct btrfs_root *root,
2831 struct btrfs_path *path,
Chris Masond20f7042008-12-08 16:58:54 -05002832 u64 bytenr, int cow);
Chris Mason1de037a2007-05-29 15:17:08 -04002833int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
2834 struct btrfs_root *root, struct btrfs_path *path,
2835 u64 isize);
Arne Jansena2de7332011-03-08 14:14:00 +01002836int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
2837 struct list_head *list, int search_commit);
Chris Mason39279cc2007-06-12 06:35:45 -04002838/* inode.c */
Josef Bacikb2675152011-07-18 13:21:36 -04002839struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
2840 size_t pg_offset, u64 start, u64 len,
2841 int create);
Chris Mason4881ee52008-07-24 09:51:08 -04002842
2843/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
Eric Sandeen5036f532008-08-07 11:19:42 -04002844#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
Chris Mason4881ee52008-07-24 09:51:08 -04002845#define ClearPageChecked ClearPageFsMisc
2846#define SetPageChecked SetPageFsMisc
2847#define PageChecked PageFsMisc
2848#endif
2849
Li Zefanb6973aa2011-07-20 03:46:35 +00002850/* This forces readahead on a given range of bytes in an inode */
2851static inline void btrfs_force_ra(struct address_space *mapping,
2852 struct file_ra_state *ra, struct file *file,
2853 pgoff_t offset, unsigned long req_size)
2854{
2855 page_cache_sync_readahead(mapping, ra, file, offset, req_size);
2856}
2857
Chris Mason3de45862008-11-17 21:02:50 -05002858struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
2859int btrfs_set_inode_index(struct inode *dir, u64 *index);
Chris Masone02119d2008-09-05 16:13:11 -04002860int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2861 struct btrfs_root *root,
2862 struct inode *dir, struct inode *inode,
2863 const char *name, int name_len);
2864int btrfs_add_link(struct btrfs_trans_handle *trans,
2865 struct inode *parent_inode, struct inode *inode,
2866 const char *name, int name_len, int add_backref, u64 index);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04002867int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
2868 struct btrfs_root *root,
2869 struct inode *dir, u64 objectid,
2870 const char *name, int name_len);
Chris Masone02119d2008-09-05 16:13:11 -04002871int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
2872 struct btrfs_root *root,
2873 struct inode *inode, u64 new_size,
2874 u32 min_type);
2875
Yan, Zheng24bbcf02009-11-12 09:36:34 +00002876int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
Josef Bacik2ac55d42010-02-03 19:33:23 +00002877int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
2878 struct extent_state **cached_state);
Chris Masonf4219502008-07-22 11:18:09 -04002879int btrfs_writepages(struct address_space *mapping,
2880 struct writeback_control *wbc);
Yan Zhengd2fb3432008-12-11 16:30:39 -05002881int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
Josef Bacikd82a6f12011-05-11 15:26:06 -04002882 struct btrfs_root *new_root, u64 new_dirid);
Chris Mason239b14b2008-03-24 15:02:07 -04002883int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
Chris Masonc8b97812008-10-29 14:49:59 -04002884 size_t size, struct bio *bio, unsigned long bio_flags);
Chris Mason239b14b2008-03-24 15:02:07 -04002885
Nick Pigginc2ec1752009-03-31 15:23:21 -07002886int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
Chris Mason9ebefb182007-06-15 13:50:00 -04002887int btrfs_readpage(struct file *file, struct page *page);
Al Virobd555972010-06-07 11:35:40 -04002888void btrfs_evict_inode(struct inode *inode);
Christoph Hellwiga9185b42010-03-05 09:21:37 +01002889int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
Josef Bacik22c44fe2011-11-30 10:45:38 -05002890int btrfs_dirty_inode(struct inode *inode);
2891int btrfs_update_time(struct file *file);
Chris Mason39279cc2007-06-12 06:35:45 -04002892struct inode *btrfs_alloc_inode(struct super_block *sb);
2893void btrfs_destroy_inode(struct inode *inode);
Al Viro45321ac2010-06-07 13:43:19 -04002894int btrfs_drop_inode(struct inode *inode);
Chris Mason39279cc2007-06-12 06:35:45 -04002895int btrfs_init_cachep(void);
2896void btrfs_destroy_cachep(void);
Sage Weil6bf13c02008-06-10 10:07:39 -04002897long btrfs_ioctl_trans_end(struct file *file);
Balaji Rao1a54ef82008-07-21 02:01:04 +05302898struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
Josef Bacik73f73412009-12-04 17:38:27 +00002899 struct btrfs_root *root, int *was_new);
Chris Masona52d9a82007-08-27 16:49:44 -04002900struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
David Sterba306e16c2011-04-19 14:29:38 +02002901 size_t pg_offset, u64 start, u64 end,
Chris Masona52d9a82007-08-27 16:49:44 -04002902 int create);
2903int btrfs_update_inode(struct btrfs_trans_handle *trans,
2904 struct btrfs_root *root,
2905 struct inode *inode);
Zheng Yan5b21f2e2008-09-26 10:05:38 -04002906int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
2907int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
Josef Bacik66b4ffd2011-01-31 16:22:42 -05002908int btrfs_orphan_cleanup(struct btrfs_root *root);
Yan, Zhengd68fc572010-05-16 10:49:58 -04002909void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
2910 struct btrfs_root *root);
Josef Bacika41ad392011-01-31 15:30:16 -05002911int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
Yan, Zheng76dda932009-09-21 16:00:26 -04002912int btrfs_invalidate_inodes(struct btrfs_root *root);
Yan, Zheng24bbcf02009-11-12 09:36:34 +00002913void btrfs_add_delayed_iput(struct inode *inode);
2914void btrfs_run_delayed_iputs(struct btrfs_root *root);
Yan, Zhengefa56462010-05-16 10:49:59 -04002915int btrfs_prealloc_file_range(struct inode *inode, int mode,
2916 u64 start, u64 num_bytes, u64 min_size,
2917 loff_t actual_len, u64 *alloc_hint);
Josef Bacik0af3d002010-06-21 14:48:16 -04002918int btrfs_prealloc_file_range_trans(struct inode *inode,
2919 struct btrfs_trans_handle *trans, int mode,
2920 u64 start, u64 num_bytes, u64 min_size,
2921 loff_t actual_len, u64 *alloc_hint);
Alexey Dobriyan82d339d2009-10-09 09:54:36 -04002922extern const struct dentry_operations btrfs_dentry_operations;
Christoph Hellwigf46b5a62008-06-11 21:53:53 -04002923
2924/* ioctl.c */
2925long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Christoph Hellwig6cbff002009-04-17 10:37:41 +02002926void btrfs_update_iflags(struct inode *inode);
2927void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
Chris Mason4cb53002011-05-24 15:35:30 -04002928int btrfs_defrag_file(struct inode *inode, struct file *file,
2929 struct btrfs_ioctl_defrag_range_args *range,
2930 u64 newer_than, unsigned long max_pages);
Chris Mason39279cc2007-06-12 06:35:45 -04002931/* file.c */
Chris Mason4cb53002011-05-24 15:35:30 -04002932int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
2933 struct inode *inode);
2934int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
Josef Bacik02c24a82011-07-16 20:44:56 -04002935int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
Zheng Yan5b21f2e2008-09-26 10:05:38 -04002936int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
2937 int skip_pinned);
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002938extern const struct file_operations btrfs_file_operations;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00002939int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
2940 u64 start, u64 end, u64 *hint_byte, int drop_cache);
Yan Zhengd899e052008-10-30 14:25:28 -04002941int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
Yan Zhengd899e052008-10-30 14:25:28 -04002942 struct inode *inode, u64 start, u64 end);
Sage Weil6bf13c02008-06-10 10:07:39 -04002943int btrfs_release_file(struct inode *inode, struct file *file);
Josef Bacikbe1a12a2011-04-06 13:05:22 -04002944void btrfs_drop_pages(struct page **pages, size_t num_pages);
2945int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
2946 struct page **pages, size_t num_pages,
2947 loff_t pos, size_t write_bytes,
2948 struct extent_state **cached);
Sage Weil6bf13c02008-06-10 10:07:39 -04002949
Chris Mason6702ed42007-08-07 16:15:09 -04002950/* tree-defrag.c */
2951int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
2952 struct btrfs_root *root, int cache_only);
Josef Bacik58176a92007-08-29 15:47:34 -04002953
2954/* sysfs.c */
2955int btrfs_init_sysfs(void);
2956void btrfs_exit_sysfs(void);
Josef Bacik58176a92007-08-29 15:47:34 -04002957
Josef Bacik5103e942007-11-16 11:45:54 -05002958/* xattr.c */
2959ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
Josef Bacik6099afe2008-07-24 12:16:03 -04002960
Chris Masonedbd8d42007-12-21 16:27:24 -05002961/* super.c */
Christoph Hellwigedf24ab2008-06-10 10:40:29 -04002962int btrfs_parse_options(struct btrfs_root *root, char *options);
Sage Weil6bf13c02008-06-10 10:07:39 -04002963int btrfs_sync_fs(struct super_block *sb, int wait);
liuboacce9522011-01-06 19:30:25 +08002964void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
2965 unsigned int line, int errno);
2966
2967#define btrfs_std_error(fs_info, errno) \
2968do { \
2969 if ((errno)) \
2970 __btrfs_std_error((fs_info), __func__, __LINE__, (errno));\
2971} while (0)
Josef Bacik33268ea2008-07-24 12:16:36 -04002972
2973/* acl.c */
Chris Mason0eda2942009-10-13 13:50:18 -04002974#ifdef CONFIG_BTRFS_FS_POSIX_ACL
Christoph Hellwig4e34e712011-07-23 17:37:31 +02002975struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
Yan, Zhengf34f57a2009-11-12 09:35:27 +00002976int btrfs_init_acl(struct btrfs_trans_handle *trans,
2977 struct inode *inode, struct inode *dir);
Josef Bacik33268ea2008-07-24 12:16:36 -04002978int btrfs_acl_chmod(struct inode *inode);
Li Zefan9b89d952011-07-14 03:17:39 +00002979#else
Linus Torvaldsed8f3732011-08-02 21:14:05 -10002980#define btrfs_get_acl NULL
Li Zefan9b89d952011-07-14 03:17:39 +00002981static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
2982 struct inode *inode, struct inode *dir)
2983{
2984 return 0;
2985}
2986static inline int btrfs_acl_chmod(struct inode *inode)
2987{
2988 return 0;
2989}
2990#endif
Josef Bacik0f9dd462008-09-23 13:14:11 -04002991
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002992/* relocation.c */
2993int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
2994int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
2995 struct btrfs_root *root);
2996int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
2997 struct btrfs_root *root);
2998int btrfs_recover_relocation(struct btrfs_root *root);
2999int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04003000void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3001 struct btrfs_root *root, struct extent_buffer *buf,
3002 struct extent_buffer *cow);
3003void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
3004 struct btrfs_pending_snapshot *pending,
3005 u64 *bytes_to_reserve);
3006void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3007 struct btrfs_pending_snapshot *pending);
Arne Jansena2de7332011-03-08 14:14:00 +01003008
3009/* scrub.c */
3010int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
Arne Jansen86287642011-03-23 16:34:19 +01003011 struct btrfs_scrub_progress *progress, int readonly);
Arne Jansena2de7332011-03-08 14:14:00 +01003012int btrfs_scrub_pause(struct btrfs_root *root);
3013int btrfs_scrub_pause_super(struct btrfs_root *root);
3014int btrfs_scrub_continue(struct btrfs_root *root);
3015int btrfs_scrub_continue_super(struct btrfs_root *root);
3016int btrfs_scrub_cancel(struct btrfs_root *root);
3017int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev);
3018int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid);
3019int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
3020 struct btrfs_scrub_progress *progress);
3021
Arne Jansen7414a032011-05-23 14:33:49 +02003022/* reada.c */
3023struct reada_control {
3024 struct btrfs_root *root; /* tree to prefetch */
3025 struct btrfs_key key_start;
3026 struct btrfs_key key_end; /* exclusive */
3027 atomic_t elems;
3028 struct kref refcnt;
3029 wait_queue_head_t wait;
3030};
3031struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3032 struct btrfs_key *start, struct btrfs_key *end);
3033int btrfs_reada_wait(void *handle);
3034void btrfs_reada_detach(void *handle);
3035int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,
3036 u64 start, int err);
3037
Chris Masoneb60cea2007-02-02 09:18:22 -05003038#endif