inode.c 230.4 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

19
#include <linux/kernel.h>
20
#include <linux/bio.h>
C
Chris Mason 已提交
21
#include <linux/buffer_head.h>
S
Sage Weil 已提交
22
#include <linux/file.h>
C
Chris Mason 已提交
23 24 25 26 27 28 29 30 31 32 33 34
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/backing-dev.h>
#include <linux/mpage.h>
#include <linux/swap.h>
#include <linux/writeback.h>
#include <linux/statfs.h>
#include <linux/compat.h>
C
Chris Mason 已提交
35
#include <linux/bit_spinlock.h>
J
Josef Bacik 已提交
36
#include <linux/xattr.h>
J
Josef Bacik 已提交
37
#include <linux/posix_acl.h>
Y
Yan Zheng 已提交
38
#include <linux/falloc.h>
39
#include <linux/slab.h>
40
#include <linux/ratelimit.h>
41
#include <linux/mount.h>
42
#include <linux/btrfs.h>
D
David Woodhouse 已提交
43
#include <linux/blkdev.h>
44
#include <linux/posix_acl_xattr.h>
C
Chris Mason 已提交
45
#include "compat.h"
C
Chris Mason 已提交
46 47 48 49 50
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "print-tree.h"
51
#include "ordered-data.h"
52
#include "xattr.h"
53
#include "tree-log.h"
54
#include "volumes.h"
C
Chris Mason 已提交
55
#include "compression.h"
56
#include "locking.h"
57
#include "free-space-cache.h"
58
#include "inode-map.h"
L
Liu Bo 已提交
59
#include "backref.h"
60
#include "hash.h"
C
Chris Mason 已提交
61 62 63 64 65 66

struct btrfs_iget_args {
	u64 ino;
	struct btrfs_root *root;
};

67 68 69 70 71
static const struct inode_operations btrfs_dir_inode_operations;
static const struct inode_operations btrfs_symlink_inode_operations;
static const struct inode_operations btrfs_dir_ro_inode_operations;
static const struct inode_operations btrfs_special_inode_operations;
static const struct inode_operations btrfs_file_inode_operations;
72 73
static const struct address_space_operations btrfs_aops;
static const struct address_space_operations btrfs_symlink_aops;
74
static const struct file_operations btrfs_dir_file_operations;
75
static struct extent_io_ops btrfs_extent_io_ops;
C
Chris Mason 已提交
76 77

static struct kmem_cache *btrfs_inode_cachep;
78
static struct kmem_cache *btrfs_delalloc_work_cachep;
C
Chris Mason 已提交
79 80 81
struct kmem_cache *btrfs_trans_handle_cachep;
struct kmem_cache *btrfs_transaction_cachep;
struct kmem_cache *btrfs_path_cachep;
82
struct kmem_cache *btrfs_free_space_cachep;
C
Chris Mason 已提交
83 84 85 86 87 88 89 90 91 92 93 94

#define S_SHIFT 12
static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
	[S_IFREG >> S_SHIFT]	= BTRFS_FT_REG_FILE,
	[S_IFDIR >> S_SHIFT]	= BTRFS_FT_DIR,
	[S_IFCHR >> S_SHIFT]	= BTRFS_FT_CHRDEV,
	[S_IFBLK >> S_SHIFT]	= BTRFS_FT_BLKDEV,
	[S_IFIFO >> S_SHIFT]	= BTRFS_FT_FIFO,
	[S_IFSOCK >> S_SHIFT]	= BTRFS_FT_SOCK,
	[S_IFLNK >> S_SHIFT]	= BTRFS_FT_SYMLINK,
};

95
static int btrfs_setsize(struct inode *inode, struct iattr *attr);
96
static int btrfs_truncate(struct inode *inode);
97
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
98 99 100 101
static noinline int cow_file_range(struct inode *inode,
				   struct page *locked_page,
				   u64 start, u64 end, int *page_started,
				   unsigned long *nr_written, int unlock);
102 103 104
static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
					   u64 len, u64 orig_start,
					   u64 block_start, u64 block_len,
J
Josef Bacik 已提交
105 106
					   u64 orig_block_len, u64 ram_bytes,
					   int type);
107

108 109
static int btrfs_dirty_inode(struct inode *inode);

110
static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
111 112
				     struct inode *inode,  struct inode *dir,
				     const struct qstr *qstr)
J
Jim Owens 已提交
113 114 115
{
	int err;

116
	err = btrfs_init_acl(trans, inode, dir);
J
Jim Owens 已提交
117
	if (!err)
118
		err = btrfs_xattr_security_init(trans, inode, dir, qstr);
J
Jim Owens 已提交
119 120 121
	return err;
}

C
Chris Mason 已提交
122 123 124 125 126
/*
 * this does all the hard work for inserting an inline extent into
 * the btree.  The caller should have done a btrfs_drop_extents so that
 * no overlapping inline items exist in the btree
 */
C
Chris Mason 已提交
127
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
128 129
				struct btrfs_root *root, struct inode *inode,
				u64 start, size_t size, size_t compressed_size,
130
				int compress_type,
C
Chris Mason 已提交
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
				struct page **compressed_pages)
{
	struct btrfs_key key;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct page *page = NULL;
	char *kaddr;
	unsigned long ptr;
	struct btrfs_file_extent_item *ei;
	int err = 0;
	int ret;
	size_t cur_size = size;
	size_t datasize;
	unsigned long offset;

146
	if (compressed_size && compressed_pages)
C
Chris Mason 已提交
147 148
		cur_size = compressed_size;

C
Chris Mason 已提交
149 150
	path = btrfs_alloc_path();
	if (!path)
C
Chris Mason 已提交
151 152
		return -ENOMEM;

153
	path->leave_spinning = 1;
C
Chris Mason 已提交
154

L
Li Zefan 已提交
155
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	key.offset = start;
	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
	datasize = btrfs_file_extent_calc_inline_size(cur_size);

	inode_add_bytes(inode, size);
	ret = btrfs_insert_empty_item(trans, root, path, &key,
				      datasize);
	if (ret) {
		err = ret;
		goto fail;
	}
	leaf = path->nodes[0];
	ei = btrfs_item_ptr(leaf, path->slots[0],
			    struct btrfs_file_extent_item);
	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
	btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
	btrfs_set_file_extent_encryption(leaf, ei, 0);
	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
	btrfs_set_file_extent_ram_bytes(leaf, ei, size);
	ptr = btrfs_file_extent_inline_start(ei);

177
	if (compress_type != BTRFS_COMPRESS_NONE) {
C
Chris Mason 已提交
178 179
		struct page *cpage;
		int i = 0;
C
Chris Mason 已提交
180
		while (compressed_size > 0) {
C
Chris Mason 已提交
181
			cpage = compressed_pages[i];
182
			cur_size = min_t(unsigned long, compressed_size,
C
Chris Mason 已提交
183 184
				       PAGE_CACHE_SIZE);

185
			kaddr = kmap_atomic(cpage);
C
Chris Mason 已提交
186
			write_extent_buffer(leaf, kaddr, ptr, cur_size);
187
			kunmap_atomic(kaddr);
C
Chris Mason 已提交
188 189 190 191 192 193

			i++;
			ptr += cur_size;
			compressed_size -= cur_size;
		}
		btrfs_set_file_extent_compression(leaf, ei,
194
						  compress_type);
C
Chris Mason 已提交
195 196 197 198
	} else {
		page = find_get_page(inode->i_mapping,
				     start >> PAGE_CACHE_SHIFT);
		btrfs_set_file_extent_compression(leaf, ei, 0);
199
		kaddr = kmap_atomic(page);
C
Chris Mason 已提交
200 201
		offset = start & (PAGE_CACHE_SIZE - 1);
		write_extent_buffer(leaf, kaddr + offset, ptr, size);
202
		kunmap_atomic(kaddr);
C
Chris Mason 已提交
203 204 205 206 207
		page_cache_release(page);
	}
	btrfs_mark_buffer_dirty(leaf);
	btrfs_free_path(path);

208 209 210 211 212 213 214 215 216
	/*
	 * we're an inline extent, so nobody can
	 * extend the file past i_size without locking
	 * a page we already have locked.
	 *
	 * We must do any isize and inode updates
	 * before we unlock the pages.  Otherwise we
	 * could end up racing with unlink.
	 */
C
Chris Mason 已提交
217
	BTRFS_I(inode)->disk_i_size = inode->i_size;
218
	ret = btrfs_update_inode(trans, root, inode);
219

220
	return ret;
C
Chris Mason 已提交
221 222 223 224 225 226 227 228 229 230 231
fail:
	btrfs_free_path(path);
	return err;
}


/*
 * conditionally insert an inline extent into the file.  This
 * does the checks required to make sure the data is small enough
 * to fit as an inline extent.
 */
232
static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
233 234
				 struct btrfs_root *root,
				 struct inode *inode, u64 start, u64 end,
235
				 size_t compressed_size, int compress_type,
C
Chris Mason 已提交
236 237 238 239 240
				 struct page **compressed_pages)
{
	u64 isize = i_size_read(inode);
	u64 actual_end = min(end + 1, isize);
	u64 inline_len = actual_end - start;
241
	u64 aligned_end = ALIGN(end, root->sectorsize);
C
Chris Mason 已提交
242 243 244 245 246 247 248
	u64 data_len = inline_len;
	int ret;

	if (compressed_size)
		data_len = compressed_size;

	if (start > 0 ||
C
Chris Mason 已提交
249
	    actual_end >= PAGE_CACHE_SIZE ||
C
Chris Mason 已提交
250 251 252 253 254 255 256 257
	    data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
	    (!compressed_size &&
	    (actual_end & (root->sectorsize - 1)) == 0) ||
	    end + 1 < isize ||
	    data_len > root->fs_info->max_inline) {
		return 1;
	}

258
	ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
259 260
	if (ret)
		return ret;
C
Chris Mason 已提交
261 262 263 264 265

	if (isize > actual_end)
		inline_len = min_t(u64, isize, actual_end);
	ret = insert_inline_extent(trans, root, inode, start,
				   inline_len, compressed_size,
266
				   compress_type, compressed_pages);
267
	if (ret && ret != -ENOSPC) {
268 269
		btrfs_abort_transaction(trans, root, ret);
		return ret;
270 271
	} else if (ret == -ENOSPC) {
		return 1;
272
	}
273

274
	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
275
	btrfs_delalloc_release_metadata(inode, end + 1 - start);
C
Chris Mason 已提交
276
	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
C
Chris Mason 已提交
277 278 279
	return 0;
}

280 281 282 283 284 285
struct async_extent {
	u64 start;
	u64 ram_size;
	u64 compressed_size;
	struct page **pages;
	unsigned long nr_pages;
286
	int compress_type;
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	struct list_head list;
};

struct async_cow {
	struct inode *inode;
	struct btrfs_root *root;
	struct page *locked_page;
	u64 start;
	u64 end;
	struct list_head extents;
	struct btrfs_work work;
};

static noinline int add_async_extent(struct async_cow *cow,
				     u64 start, u64 ram_size,
				     u64 compressed_size,
				     struct page **pages,
304 305
				     unsigned long nr_pages,
				     int compress_type)
306 307 308 309
{
	struct async_extent *async_extent;

	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
310
	BUG_ON(!async_extent); /* -ENOMEM */
311 312 313 314 315
	async_extent->start = start;
	async_extent->ram_size = ram_size;
	async_extent->compressed_size = compressed_size;
	async_extent->pages = pages;
	async_extent->nr_pages = nr_pages;
316
	async_extent->compress_type = compress_type;
317 318 319 320
	list_add_tail(&async_extent->list, &cow->extents);
	return 0;
}

C
Chris Mason 已提交
321
/*
322 323 324
 * we create compressed extents in two phases.  The first
 * phase compresses a range of pages that have already been
 * locked (both pages and state bits are locked).
C
Chris Mason 已提交
325
 *
326 327 328 329 330
 * This is done inside an ordered work queue, and the compression
 * is spread across many cpus.  The actual IO submission is step
 * two, and the ordered work queue takes care of making sure that
 * happens in the same order things were put onto the queue by
 * writepages and friends.
C
Chris Mason 已提交
331
 *
332 333 334
 * If this code finds it can't get good compression, it puts an
 * entry onto the work queue to write the uncompressed bytes.  This
 * makes sure that both compressed inodes and uncompressed inodes
335 336
 * are written in the same order that the flusher thread sent them
 * down.
C
Chris Mason 已提交
337
 */
338 339 340 341 342
static noinline int compress_file_range(struct inode *inode,
					struct page *locked_page,
					u64 start, u64 end,
					struct async_cow *async_cow,
					int *num_added)
343 344 345
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
346 347
	u64 num_bytes;
	u64 blocksize = root->sectorsize;
C
Chris Mason 已提交
348
	u64 actual_end;
349
	u64 isize = i_size_read(inode);
350
	int ret = 0;
C
Chris Mason 已提交
351 352 353 354 355 356
	struct page **pages = NULL;
	unsigned long nr_pages;
	unsigned long nr_pages_ret = 0;
	unsigned long total_compressed = 0;
	unsigned long total_in = 0;
	unsigned long max_compressed = 128 * 1024;
357
	unsigned long max_uncompressed = 128 * 1024;
C
Chris Mason 已提交
358 359
	int i;
	int will_compress;
360
	int compress_type = root->fs_info->compress_type;
361
	int redirty = 0;
362

363 364 365
	/* if this is a small write inside eof, kick off a defrag */
	if ((end - start + 1) < 16 * 1024 &&
	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
C
Chris Mason 已提交
366 367
		btrfs_add_inode_defrag(NULL, inode);

368
	actual_end = min_t(u64, isize, end + 1);
C
Chris Mason 已提交
369 370 371 372
again:
	will_compress = 0;
	nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
	nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
373

374 375 376 377 378 379 380 381 382 383 384 385 386
	/*
	 * we don't want to send crud past the end of i_size through
	 * compression, that's just a waste of CPU time.  So, if the
	 * end of the file is before the start of our current
	 * requested range of bytes, we bail out to the uncompressed
	 * cleanup code that can deal with all of this.
	 *
	 * It isn't really the fastest way to fix things, but this is a
	 * very uncommon corner.
	 */
	if (actual_end <= start)
		goto cleanup_and_bail_uncompressed;

C
Chris Mason 已提交
387 388 389 390
	total_compressed = actual_end - start;

	/* we want to make sure that amount of ram required to uncompress
	 * an extent is reasonable, so we limit the total size in ram
391 392 393 394 395 396 397
	 * of a compressed extent to 128k.  This is a crucial number
	 * because it also controls how easily we can spread reads across
	 * cpus for decompression.
	 *
	 * We also want to make sure the amount of IO required to do
	 * a random read is reasonably small, so we limit the size of
	 * a compressed extent to 128k.
C
Chris Mason 已提交
398 399
	 */
	total_compressed = min(total_compressed, max_uncompressed);
400
	num_bytes = ALIGN(end - start + 1, blocksize);
401
	num_bytes = max(blocksize,  num_bytes);
C
Chris Mason 已提交
402 403
	total_in = 0;
	ret = 0;
404

405 406 407 408
	/*
	 * we do compression for mount -o compress and when the
	 * inode has not been flagged as nocompress.  This flag can
	 * change at any time if we discover bad compression ratios.
C
Chris Mason 已提交
409
	 */
410
	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
C
Chris Mason 已提交
411
	    (btrfs_test_opt(root, COMPRESS) ||
412 413
	     (BTRFS_I(inode)->force_compress) ||
	     (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
C
Chris Mason 已提交
414
		WARN_ON(pages);
415
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
416 417 418 419
		if (!pages) {
			/* just bail out to the uncompressed code */
			goto cont;
		}
C
Chris Mason 已提交
420

421 422 423
		if (BTRFS_I(inode)->force_compress)
			compress_type = BTRFS_I(inode)->force_compress;

424 425 426 427 428 429 430 431 432 433 434
		/*
		 * we need to call clear_page_dirty_for_io on each
		 * page in the range.  Otherwise applications with the file
		 * mmap'd can wander in and change the page contents while
		 * we are compressing them.
		 *
		 * If the compression fails for any reason, we set the pages
		 * dirty again later on.
		 */
		extent_range_clear_dirty_for_io(inode, start, end);
		redirty = 1;
435 436 437 438 439 440 441
		ret = btrfs_compress_pages(compress_type,
					   inode->i_mapping, start,
					   total_compressed, pages,
					   nr_pages, &nr_pages_ret,
					   &total_in,
					   &total_compressed,
					   max_compressed);
C
Chris Mason 已提交
442 443 444 445 446 447 448 449 450 451 452

		if (!ret) {
			unsigned long offset = total_compressed &
				(PAGE_CACHE_SIZE - 1);
			struct page *page = pages[nr_pages_ret - 1];
			char *kaddr;

			/* zero the tail end of the last page, we might be
			 * sending it down to disk
			 */
			if (offset) {
453
				kaddr = kmap_atomic(page);
C
Chris Mason 已提交
454 455
				memset(kaddr + offset, 0,
				       PAGE_CACHE_SIZE - offset);
456
				kunmap_atomic(kaddr);
C
Chris Mason 已提交
457 458 459 460
			}
			will_compress = 1;
		}
	}
461
cont:
C
Chris Mason 已提交
462
	if (start == 0) {
463
		trans = btrfs_join_transaction(root);
464 465 466 467 468
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
			trans = NULL;
			goto cleanup_and_out;
		}
469
		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
470

C
Chris Mason 已提交
471
		/* lets try to make an inline extent */
472
		if (ret || total_in < (actual_end - start)) {
C
Chris Mason 已提交
473
			/* we didn't compress the entire range, try
474
			 * to make an uncompressed inline extent.
C
Chris Mason 已提交
475 476
			 */
			ret = cow_file_range_inline(trans, root, inode,
477
						    start, end, 0, 0, NULL);
C
Chris Mason 已提交
478
		} else {
479
			/* try making a compressed inline extent */
C
Chris Mason 已提交
480 481
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
482 483
						    total_compressed,
						    compress_type, pages);
C
Chris Mason 已提交
484
		}
485
		if (ret <= 0) {
486
			/*
487 488 489
			 * inline extent creation worked or returned error,
			 * we don't need to create any more async work items.
			 * Unlock and free up our temp pages.
490
			 */
C
Chris Mason 已提交
491
			extent_clear_unlock_delalloc(inode,
492 493 494
			     &BTRFS_I(inode)->io_tree,
			     start, end, NULL,
			     EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
495
			     EXTENT_CLEAR_DELALLOC |
496
			     EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
497 498

			btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
499 500
			goto free_pages_out;
		}
501
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
502 503 504 505 506 507 508 509
	}

	if (will_compress) {
		/*
		 * we aren't doing an inline extent round the compressed size
		 * up to a block size boundary so the allocator does sane
		 * things
		 */
510
		total_compressed = ALIGN(total_compressed, blocksize);
C
Chris Mason 已提交
511 512 513 514 515

		/*
		 * one last check to make sure the compression is really a
		 * win, compare the page count read with the blocks on disk
		 */
516
		total_in = ALIGN(total_in, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
517 518 519 520 521 522 523 524 525 526 527 528
		if (total_compressed >= total_in) {
			will_compress = 0;
		} else {
			num_bytes = total_in;
		}
	}
	if (!will_compress && pages) {
		/*
		 * the compression code ran but failed to make things smaller,
		 * free any pages it allocated and our page pointer array
		 */
		for (i = 0; i < nr_pages_ret; i++) {
C
Chris Mason 已提交
529
			WARN_ON(pages[i]->mapping);
C
Chris Mason 已提交
530 531 532 533 534 535 536 537
			page_cache_release(pages[i]);
		}
		kfree(pages);
		pages = NULL;
		total_compressed = 0;
		nr_pages_ret = 0;

		/* flag the file so we don't compress in the future */
C
Chris Mason 已提交
538 539
		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
		    !(BTRFS_I(inode)->force_compress)) {
C
Chris Mason 已提交
540
			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
C
Chris Mason 已提交
541
		}
C
Chris Mason 已提交
542
	}
543 544
	if (will_compress) {
		*num_added += 1;
C
Chris Mason 已提交
545

546 547 548 549 550
		/* the async work queues will take care of doing actual
		 * allocation on disk for these compressed pages,
		 * and will submit them to the elevator.
		 */
		add_async_extent(async_cow, start, num_bytes,
551 552
				 total_compressed, pages, nr_pages_ret,
				 compress_type);
553

554
		if (start + num_bytes < end) {
555 556 557 558 559 560
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
561
cleanup_and_bail_uncompressed:
562 563 564 565 566 567 568 569 570 571 572 573
		/*
		 * No compression, but we still need to write the pages in
		 * the file we've been given so far.  redirty the locked
		 * page if it corresponds to our extent and set things up
		 * for the async work queue to run cow_file_range to do
		 * the normal delalloc dance
		 */
		if (page_offset(locked_page) >= start &&
		    page_offset(locked_page) <= end) {
			__set_page_dirty_nobuffers(locked_page);
			/* unlocked later on in the async handlers */
		}
574 575
		if (redirty)
			extent_range_redirty_for_io(inode, start, end);
576 577
		add_async_extent(async_cow, start, end - start + 1,
				 0, NULL, 0, BTRFS_COMPRESS_NONE);
578 579
		*num_added += 1;
	}
580

581
out:
582
	return ret;
583 584 585 586 587 588

free_pages_out:
	for (i = 0; i < nr_pages_ret; i++) {
		WARN_ON(pages[i]->mapping);
		page_cache_release(pages[i]);
	}
C
Chris Mason 已提交
589
	kfree(pages);
590 591

	goto out;
592 593 594 595 596 597 598 599 600 601 602 603 604 605

cleanup_and_out:
	extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
				     start, end, NULL,
				     EXTENT_CLEAR_UNLOCK_PAGE |
				     EXTENT_CLEAR_DIRTY |
				     EXTENT_CLEAR_DELALLOC |
				     EXTENT_SET_WRITEBACK |
				     EXTENT_END_WRITEBACK);
	if (!trans || IS_ERR(trans))
		btrfs_error(root->fs_info, ret, "Failed to join transaction");
	else
		btrfs_abort_transaction(trans, root, ret);
	goto free_pages_out;
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
}

/*
 * phase two of compressed writeback.  This is the ordered portion
 * of the code, which only gets called in the order the work was
 * queued.  We walk all the async extents created by compress_file_range
 * and send them down to the disk.
 */
static noinline int submit_compressed_extents(struct inode *inode,
					      struct async_cow *async_cow)
{
	struct async_extent *async_extent;
	u64 alloc_hint = 0;
	struct btrfs_trans_handle *trans;
	struct btrfs_key ins;
	struct extent_map *em;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_io_tree *io_tree;
625
	int ret = 0;
626 627 628 629

	if (list_empty(&async_cow->extents))
		return 0;

630
again:
C
Chris Mason 已提交
631
	while (!list_empty(&async_cow->extents)) {
632 633 634
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
C
Chris Mason 已提交
635

636 637
		io_tree = &BTRFS_I(inode)->io_tree;

638
retry:
639 640 641 642 643 644
		/* did the compression code fall back to uncompressed IO? */
		if (!async_extent->pages) {
			int page_started = 0;
			unsigned long nr_written = 0;

			lock_extent(io_tree, async_extent->start,
645
					 async_extent->start +
646
					 async_extent->ram_size - 1);
647 648

			/* allocate blocks */
649 650 651 652 653
			ret = cow_file_range(inode, async_cow->locked_page,
					     async_extent->start,
					     async_extent->start +
					     async_extent->ram_size - 1,
					     &page_started, &nr_written, 0);
654

655 656
			/* JDM XXX */

657 658 659 660 661 662
			/*
			 * if page_started, cow_file_range inserted an
			 * inline extent and took care of all the unlocking
			 * and IO for us.  Otherwise, we need to submit
			 * all those pages down to the drive.
			 */
663
			if (!page_started && !ret)
664 665
				extent_write_locked_range(io_tree,
						  inode, async_extent->start,
C
Chris Mason 已提交
666
						  async_extent->start +
667 668 669
						  async_extent->ram_size - 1,
						  btrfs_get_extent,
						  WB_SYNC_ALL);
670 671
			else if (ret)
				unlock_page(async_cow->locked_page);
672 673 674 675 676 677
			kfree(async_extent);
			cond_resched();
			continue;
		}

		lock_extent(io_tree, async_extent->start,
678
			    async_extent->start + async_extent->ram_size - 1);
679

680
		trans = btrfs_join_transaction(root);
681 682 683 684 685
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
		} else {
			trans->block_rsv = &root->fs_info->delalloc_block_rsv;
			ret = btrfs_reserve_extent(trans, root,
686 687
					   async_extent->compressed_size,
					   async_extent->compressed_size,
688
					   0, alloc_hint, &ins, 1);
689
			if (ret && ret != -ENOSPC)
690 691 692
				btrfs_abort_transaction(trans, root, ret);
			btrfs_end_transaction(trans, root);
		}
693

694 695
		if (ret) {
			int i;
696

697 698 699 700 701 702 703
			for (i = 0; i < async_extent->nr_pages; i++) {
				WARN_ON(async_extent->pages[i]->mapping);
				page_cache_release(async_extent->pages[i]);
			}
			kfree(async_extent->pages);
			async_extent->nr_pages = 0;
			async_extent->pages = NULL;
704

705 706 707 708
			if (ret == -ENOSPC) {
				unlock_extent(io_tree, async_extent->start,
					      async_extent->start +
					      async_extent->ram_size - 1);
709
				goto retry;
710
			}
711
			goto out_free;
712 713
		}

714 715 716 717 718 719 720 721
		/*
		 * here we're doing allocation and writeback of the
		 * compressed pages
		 */
		btrfs_drop_extent_cache(inode, async_extent->start,
					async_extent->start +
					async_extent->ram_size - 1, 0);

722
		em = alloc_extent_map();
723 724
		if (!em) {
			ret = -ENOMEM;
725
			goto out_free_reserve;
726
		}
727 728
		em->start = async_extent->start;
		em->len = async_extent->ram_size;
729
		em->orig_start = em->start;
730 731
		em->mod_start = em->start;
		em->mod_len = em->len;
C
Chris Mason 已提交
732

733 734
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
735
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
736
		em->ram_bytes = async_extent->ram_size;
737
		em->bdev = root->fs_info->fs_devices->latest_bdev;
738
		em->compress_type = async_extent->compress_type;
739 740
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
741
		em->generation = -1;
742

C
Chris Mason 已提交
743
		while (1) {
744
			write_lock(&em_tree->lock);
J
Josef Bacik 已提交
745
			ret = add_extent_mapping(em_tree, em, 1);
746
			write_unlock(&em_tree->lock);
747 748 749 750 751 752 753 754 755
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, async_extent->start,
						async_extent->start +
						async_extent->ram_size - 1, 0);
		}

756 757 758
		if (ret)
			goto out_free_reserve;

759 760 761 762 763 764 765
		ret = btrfs_add_ordered_extent_compress(inode,
						async_extent->start,
						ins.objectid,
						async_extent->ram_size,
						ins.offset,
						BTRFS_ORDERED_COMPRESSED,
						async_extent->compress_type);
766 767
		if (ret)
			goto out_free_reserve;
768 769 770 771 772

		/*
		 * clear dirty, set writeback and unlock the pages.
		 */
		extent_clear_unlock_delalloc(inode,
773 774 775 776 777 778
				&BTRFS_I(inode)->io_tree,
				async_extent->start,
				async_extent->start +
				async_extent->ram_size - 1,
				NULL, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK |
779
				EXTENT_CLEAR_DELALLOC |
780
				EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
781 782

		ret = btrfs_submit_compressed_write(inode,
C
Chris Mason 已提交
783 784 785 786 787
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
788 789
		alloc_hint = ins.objectid + ins.offset;
		kfree(async_extent);
790 791
		if (ret)
			goto out;
792 793
		cond_resched();
	}
794 795 796
	ret = 0;
out:
	return ret;
797 798
out_free_reserve:
	btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
799
out_free:
800 801 802 803 804 805 806 807 808 809
	extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
				     async_extent->start,
				     async_extent->start +
				     async_extent->ram_size - 1,
				     NULL, EXTENT_CLEAR_UNLOCK_PAGE |
				     EXTENT_CLEAR_UNLOCK |
				     EXTENT_CLEAR_DELALLOC |
				     EXTENT_CLEAR_DIRTY |
				     EXTENT_SET_WRITEBACK |
				     EXTENT_END_WRITEBACK);
810
	kfree(async_extent);
811
	goto again;
812 813
}

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
				      u64 num_bytes)
{
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	u64 alloc_hint = 0;

	read_lock(&em_tree->lock);
	em = search_extent_mapping(em_tree, start, num_bytes);
	if (em) {
		/*
		 * if block start isn't an actual block number then find the
		 * first block in this inode and use that as a hint.  If that
		 * block is also bogus then just don't worry about it.
		 */
		if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
			free_extent_map(em);
			em = search_extent_mapping(em_tree, 0, 0);
			if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
				alloc_hint = em->block_start;
			if (em)
				free_extent_map(em);
		} else {
			alloc_hint = em->block_start;
			free_extent_map(em);
		}
	}
	read_unlock(&em_tree->lock);

	return alloc_hint;
}

846 847 848 849 850 851 852 853 854 855 856 857 858
/*
 * when extent_io.c finds a delayed allocation range in the file,
 * the call backs end up in this code.  The basic idea is to
 * allocate extents on disk for the range, and create ordered data structs
 * in ram to track those extents.
 *
 * locked_page is the page that writepage had locked already.  We use
 * it to make sure we don't do extra locks or unlocks.
 *
 * *page_started is set to one if we unlock locked_page and do everything
 * required to start IO on it.  It may be clean and already done with
 * IO when we return.
 */
859 860 861 862 863 864 865
static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
				     struct inode *inode,
				     struct btrfs_root *root,
				     struct page *locked_page,
				     u64 start, u64 end, int *page_started,
				     unsigned long *nr_written,
				     int unlock)
866 867 868 869 870 871 872 873 874 875 876 877
{
	u64 alloc_hint = 0;
	u64 num_bytes;
	unsigned long ram_size;
	u64 disk_num_bytes;
	u64 cur_alloc_size;
	u64 blocksize = root->sectorsize;
	struct btrfs_key ins;
	struct extent_map *em;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	int ret = 0;

878
	BUG_ON(btrfs_is_free_space_inode(inode));
879

880
	num_bytes = ALIGN(end - start + 1, blocksize);
881 882 883
	num_bytes = max(blocksize,  num_bytes);
	disk_num_bytes = num_bytes;

C
Chris Mason 已提交
884
	/* if this is a small write inside eof, kick off defrag */
885 886
	if (num_bytes < 64 * 1024 &&
	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
C
Chris Mason 已提交
887 888
		btrfs_add_inode_defrag(trans, inode);

889 890 891
	if (start == 0) {
		/* lets try to make an inline extent */
		ret = cow_file_range_inline(trans, root, inode,
892
					    start, end, 0, 0, NULL);
893 894
		if (ret == 0) {
			extent_clear_unlock_delalloc(inode,
895 896 897 898 899 900 901 902
				     &BTRFS_I(inode)->io_tree,
				     start, end, NULL,
				     EXTENT_CLEAR_UNLOCK_PAGE |
				     EXTENT_CLEAR_UNLOCK |
				     EXTENT_CLEAR_DELALLOC |
				     EXTENT_CLEAR_DIRTY |
				     EXTENT_SET_WRITEBACK |
				     EXTENT_END_WRITEBACK);
903

904 905 906 907
			*nr_written = *nr_written +
			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
			*page_started = 1;
			goto out;
908 909 910
		} else if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_unlock;
911 912 913 914
		}
	}

	BUG_ON(disk_num_bytes >
915
	       btrfs_super_total_bytes(root->fs_info->super_copy));
916

917
	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
918 919
	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

C
Chris Mason 已提交
920
	while (disk_num_bytes > 0) {
921 922
		unsigned long op;

923
		cur_alloc_size = disk_num_bytes;
924
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
925
					   root->sectorsize, 0, alloc_hint,
926
					   &ins, 1);
927 928 929 930
		if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_unlock;
		}
C
Chris Mason 已提交
931

932
		em = alloc_extent_map();
933 934
		if (!em) {
			ret = -ENOMEM;
935
			goto out_reserve;
936
		}
937
		em->start = start;
938
		em->orig_start = em->start;
939 940
		ram_size = ins.offset;
		em->len = ins.offset;
941 942
		em->mod_start = em->start;
		em->mod_len = em->len;
C
Chris Mason 已提交
943

944
		em->block_start = ins.objectid;
C
Chris Mason 已提交
945
		em->block_len = ins.offset;
946
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
947
		em->ram_bytes = ram_size;
948
		em->bdev = root->fs_info->fs_devices->latest_bdev;
949
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
950
		em->generation = -1;
C
Chris Mason 已提交
951

C
Chris Mason 已提交
952
		while (1) {
953
			write_lock(&em_tree->lock);
J
Josef Bacik 已提交
954
			ret = add_extent_mapping(em_tree, em, 1);
955
			write_unlock(&em_tree->lock);
956 957 958 959 960
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, start,
C
Chris Mason 已提交
961
						start + ram_size - 1, 0);
962
		}
963 964
		if (ret)
			goto out_reserve;
965

966
		cur_alloc_size = ins.offset;
967
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
968
					       ram_size, cur_alloc_size, 0);
969 970
		if (ret)
			goto out_reserve;
C
Chris Mason 已提交
971

972 973 974 975
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, start,
						      cur_alloc_size);
976 977
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
978
				goto out_reserve;
979
			}
980 981
		}

C
Chris Mason 已提交
982
		if (disk_num_bytes < cur_alloc_size)
983
			break;
C
Chris Mason 已提交
984

C
Chris Mason 已提交
985 986 987
		/* we're not doing compressed IO, don't unlock the first
		 * page (which the caller expects to stay locked), don't
		 * clear any dirty bits and don't set any writeback bits
988 989 990
		 *
		 * Do set the Private2 bit so we know this page was properly
		 * setup for writepage
C
Chris Mason 已提交
991
		 */
992 993 994 995
		op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
		op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
			EXTENT_SET_PRIVATE2;

C
Chris Mason 已提交
996 997
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					     start, start + ram_size - 1,
998
					     locked_page, op);
C
Chris Mason 已提交
999
		disk_num_bytes -= cur_alloc_size;
1000 1001 1002
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
1003
	}
1004
out:
1005
	return ret;
1006

1007 1008
out_reserve:
	btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
1009 1010 1011
out_unlock:
	extent_clear_unlock_delalloc(inode,
		     &BTRFS_I(inode)->io_tree,
1012
		     start, end, locked_page,
1013 1014 1015 1016 1017 1018 1019 1020
		     EXTENT_CLEAR_UNLOCK_PAGE |
		     EXTENT_CLEAR_UNLOCK |
		     EXTENT_CLEAR_DELALLOC |
		     EXTENT_CLEAR_DIRTY |
		     EXTENT_SET_WRITEBACK |
		     EXTENT_END_WRITEBACK);

	goto out;
1021
}
C
Chris Mason 已提交
1022

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
static noinline int cow_file_range(struct inode *inode,
				   struct page *locked_page,
				   u64 start, u64 end, int *page_started,
				   unsigned long *nr_written,
				   int unlock)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

	trans = btrfs_join_transaction(root);
	if (IS_ERR(trans)) {
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     start, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);
		return PTR_ERR(trans);
	}
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

	ret = __cow_file_range(trans, inode, root, locked_page, start, end,
			       page_started, nr_written, unlock);

	btrfs_end_transaction(trans, root);

	return ret;
}

1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
/*
 * work queue call back to started compression on a file and pages
 */
static noinline void async_cow_start(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	int num_added = 0;
	async_cow = container_of(work, struct async_cow, work);

	compress_file_range(async_cow->inode, async_cow->locked_page,
			    async_cow->start, async_cow->end, async_cow,
			    &num_added);
1068
	if (num_added == 0) {
1069
		btrfs_add_delayed_iput(async_cow->inode);
1070
		async_cow->inode = NULL;
1071
	}
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
}

/*
 * work queue call back to submit previously compressed pages
 */
static noinline void async_cow_submit(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	struct btrfs_root *root;
	unsigned long nr_pages;

	async_cow = container_of(work, struct async_cow, work);

	root = async_cow->root;
	nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
		PAGE_CACHE_SHIFT;

1089
	if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
1090
	    5 * 1024 * 1024 &&
1091 1092 1093
	    waitqueue_active(&root->fs_info->async_submit_wait))
		wake_up(&root->fs_info->async_submit_wait);

C
Chris Mason 已提交
1094
	if (async_cow->inode)
1095 1096
		submit_compressed_extents(async_cow->inode, async_cow);
}
C
Chris Mason 已提交
1097

1098 1099 1100 1101
static noinline void async_cow_free(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	async_cow = container_of(work, struct async_cow, work);
1102
	if (async_cow->inode)
1103
		btrfs_add_delayed_iput(async_cow->inode);
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
	kfree(async_cow);
}

static int cow_file_range_async(struct inode *inode, struct page *locked_page,
				u64 start, u64 end, int *page_started,
				unsigned long *nr_written)
{
	struct async_cow *async_cow;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	unsigned long nr_pages;
	u64 cur_end;
1115
	int limit = 10 * 1024 * 1024;
1116

1117 1118
	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
			 1, 0, NULL, GFP_NOFS);
C
Chris Mason 已提交
1119
	while (start < end) {
1120
		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
1121
		BUG_ON(!async_cow); /* -ENOMEM */
1122
		async_cow->inode = igrab(inode);
1123 1124 1125 1126
		async_cow->root = root;
		async_cow->locked_page = locked_page;
		async_cow->start = start;

1127
		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
			cur_end = end;
		else
			cur_end = min(end, start + 512 * 1024 - 1);

		async_cow->end = cur_end;
		INIT_LIST_HEAD(&async_cow->extents);

		async_cow->work.func = async_cow_start;
		async_cow->work.ordered_func = async_cow_submit;
		async_cow->work.ordered_free = async_cow_free;
		async_cow->work.flags = 0;

		nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
			PAGE_CACHE_SHIFT;
		atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);

		btrfs_queue_worker(&root->fs_info->delalloc_workers,
				   &async_cow->work);

		if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
			wait_event(root->fs_info->async_submit_wait,
			   (atomic_read(&root->fs_info->async_delalloc_pages) <
			    limit));
		}

C
Chris Mason 已提交
1153
		while (atomic_read(&root->fs_info->async_submit_draining) &&
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
		      atomic_read(&root->fs_info->async_delalloc_pages)) {
			wait_event(root->fs_info->async_submit_wait,
			  (atomic_read(&root->fs_info->async_delalloc_pages) ==
			   0));
		}

		*nr_written += nr_pages;
		start = cur_end + 1;
	}
	*page_started = 1;
	return 0;
1165 1166
}

C
Chris Mason 已提交
1167
static noinline int csum_exist_in_range(struct btrfs_root *root,
1168 1169 1170 1171 1172 1173
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

Y
Yan Zheng 已提交
1174
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
A
Arne Jansen 已提交
1175
				       bytenr + num_bytes - 1, &list, 0);
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
	if (ret == 0 && list_empty(&list))
		return 0;

	while (!list_empty(&list)) {
		sums = list_entry(list.next, struct btrfs_ordered_sum, list);
		list_del(&sums->list);
		kfree(sums);
	}
	return 1;
}

C
Chris Mason 已提交
1187 1188 1189 1190 1191 1192 1193
/*
 * when nowcow writeback call back.  This checks for snapshots or COW copies
 * of the extents that exist in the file, and COWs the file as required.
 *
 * If no cow copies or snapshots exist, we write directly to the existing
 * blocks on disk
 */
1194 1195
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
1196 1197
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
1198 1199
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1200
	struct btrfs_trans_handle *trans;
1201 1202
	struct extent_buffer *leaf;
	struct btrfs_path *path;
Y
Yan Zheng 已提交
1203
	struct btrfs_file_extent_item *fi;
1204
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
1205 1206 1207
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
1208
	u64 extent_offset;
Y
Yan Zheng 已提交
1209 1210
	u64 disk_bytenr;
	u64 num_bytes;
1211
	u64 disk_num_bytes;
J
Josef Bacik 已提交
1212
	u64 ram_bytes;
Y
Yan Zheng 已提交
1213
	int extent_type;
1214
	int ret, err;
Y
Yan Zheng 已提交
1215
	int type;
Y
Yan Zheng 已提交
1216 1217
	int nocow;
	int check_prev = 1;
1218
	bool nolock;
L
Li Zefan 已提交
1219
	u64 ino = btrfs_ino(inode);
1220 1221

	path = btrfs_alloc_path();
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
	if (!path) {
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     start, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);
1232
		return -ENOMEM;
1233
	}
1234

1235
	nolock = btrfs_is_free_space_inode(inode);
1236 1237

	if (nolock)
1238
		trans = btrfs_join_transaction_nolock(root);
1239
	else
1240
		trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
1241

1242
	if (IS_ERR(trans)) {
1243 1244 1245 1246 1247 1248 1249 1250 1251
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     start, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);
1252 1253 1254 1255
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}

1256
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1257

Y
Yan Zheng 已提交
1258 1259 1260
	cow_start = (u64)-1;
	cur_offset = start;
	while (1) {
L
Li Zefan 已提交
1261
		ret = btrfs_lookup_file_extent(trans, root, path, ino,
Y
Yan Zheng 已提交
1262
					       cur_offset, 0);
1263 1264 1265 1266
		if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
Y
Yan Zheng 已提交
1267 1268 1269 1270
		if (ret > 0 && path->slots[0] > 0 && check_prev) {
			leaf = path->nodes[0];
			btrfs_item_key_to_cpu(leaf, &found_key,
					      path->slots[0] - 1);
L
Li Zefan 已提交
1271
			if (found_key.objectid == ino &&
Y
Yan Zheng 已提交
1272 1273 1274 1275 1276 1277 1278 1279
			    found_key.type == BTRFS_EXTENT_DATA_KEY)
				path->slots[0]--;
		}
		check_prev = 0;
next_slot:
		leaf = path->nodes[0];
		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
1280 1281 1282 1283
			if (ret < 0) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
Y
Yan Zheng 已提交
1284 1285 1286 1287
			if (ret > 0)
				break;
			leaf = path->nodes[0];
		}
1288

Y
Yan Zheng 已提交
1289 1290
		nocow = 0;
		disk_bytenr = 0;
1291
		num_bytes = 0;
Y
Yan Zheng 已提交
1292 1293
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

L
Li Zefan 已提交
1294
		if (found_key.objectid > ino ||
Y
Yan Zheng 已提交
1295 1296 1297 1298 1299 1300
		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
		    found_key.offset > end)
			break;

		if (found_key.offset > cur_offset) {
			extent_end = found_key.offset;
1301
			extent_type = 0;
Y
Yan Zheng 已提交
1302 1303 1304 1305 1306 1307 1308
			goto out_check;
		}

		fi = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);
		extent_type = btrfs_file_extent_type(leaf, fi);

J
Josef Bacik 已提交
1309
		ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
Y
Yan Zheng 已提交
1310 1311
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
1312
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1313
			extent_offset = btrfs_file_extent_offset(leaf, fi);
Y
Yan Zheng 已提交
1314 1315
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
1316 1317
			disk_num_bytes =
				btrfs_file_extent_disk_num_bytes(leaf, fi);
Y
Yan Zheng 已提交
1318 1319 1320 1321
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1322 1323
			if (disk_bytenr == 0)
				goto out_check;
Y
Yan Zheng 已提交
1324 1325 1326 1327
			if (btrfs_file_extent_compression(leaf, fi) ||
			    btrfs_file_extent_encryption(leaf, fi) ||
			    btrfs_file_extent_other_encoding(leaf, fi))
				goto out_check;
Y
Yan Zheng 已提交
1328 1329
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1330
			if (btrfs_extent_readonly(root, disk_bytenr))
Y
Yan Zheng 已提交
1331
				goto out_check;
L
Li Zefan 已提交
1332
			if (btrfs_cross_ref_exist(trans, root, ino,
1333 1334
						  found_key.offset -
						  extent_offset, disk_bytenr))
1335
				goto out_check;
1336
			disk_bytenr += extent_offset;
1337 1338 1339 1340 1341 1342 1343 1344 1345
			disk_bytenr += cur_offset - found_key.offset;
			num_bytes = min(end + 1, extent_end) - cur_offset;
			/*
			 * force cow if csum exists in the range.
			 * this ensure that csum for a given extent are
			 * either valid or do not exist.
			 */
			if (csum_exist_in_range(root, disk_bytenr, num_bytes))
				goto out_check;
Y
Yan Zheng 已提交
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
			nocow = 1;
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
			extent_end = found_key.offset +
				btrfs_file_extent_inline_len(leaf, fi);
			extent_end = ALIGN(extent_end, root->sectorsize);
		} else {
			BUG_ON(1);
		}
out_check:
		if (extent_end <= start) {
			path->slots[0]++;
			goto next_slot;
		}
		if (!nocow) {
			if (cow_start == (u64)-1)
				cow_start = cur_offset;
			cur_offset = extent_end;
			if (cur_offset > end)
				break;
			path->slots[0]++;
			goto next_slot;
1367 1368
		}

1369
		btrfs_release_path(path);
Y
Yan Zheng 已提交
1370
		if (cow_start != (u64)-1) {
1371 1372 1373
			ret = __cow_file_range(trans, inode, root, locked_page,
					       cow_start, found_key.offset - 1,
					       page_started, nr_written, 1);
1374 1375 1376 1377
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
Y
Yan Zheng 已提交
1378
			cow_start = (u64)-1;
1379
		}
Y
Yan Zheng 已提交
1380

Y
Yan Zheng 已提交
1381 1382 1383 1384
		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
			struct extent_map *em;
			struct extent_map_tree *em_tree;
			em_tree = &BTRFS_I(inode)->extent_tree;
1385
			em = alloc_extent_map();
1386
			BUG_ON(!em); /* -ENOMEM */
Y
Yan Zheng 已提交
1387
			em->start = cur_offset;
1388
			em->orig_start = found_key.offset - extent_offset;
Y
Yan Zheng 已提交
1389 1390 1391
			em->len = num_bytes;
			em->block_len = num_bytes;
			em->block_start = disk_bytenr;
1392
			em->orig_block_len = disk_num_bytes;
J
Josef Bacik 已提交
1393
			em->ram_bytes = ram_bytes;
Y
Yan Zheng 已提交
1394
			em->bdev = root->fs_info->fs_devices->latest_bdev;
1395 1396
			em->mod_start = em->start;
			em->mod_len = em->len;
Y
Yan Zheng 已提交
1397
			set_bit(EXTENT_FLAG_PINNED, &em->flags);
1398
			set_bit(EXTENT_FLAG_FILLING, &em->flags);
1399
			em->generation = -1;
Y
Yan Zheng 已提交
1400
			while (1) {
1401
				write_lock(&em_tree->lock);
J
Josef Bacik 已提交
1402
				ret = add_extent_mapping(em_tree, em, 1);
1403
				write_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
				if (ret != -EEXIST) {
					free_extent_map(em);
					break;
				}
				btrfs_drop_extent_cache(inode, em->start,
						em->start + em->len - 1, 0);
			}
			type = BTRFS_ORDERED_PREALLOC;
		} else {
			type = BTRFS_ORDERED_NOCOW;
		}
Y
Yan Zheng 已提交
1415 1416

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
Y
Yan Zheng 已提交
1417
					       num_bytes, num_bytes, type);
1418
		BUG_ON(ret); /* -ENOMEM */
1419

1420 1421 1422 1423
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, cur_offset,
						      num_bytes);
1424 1425 1426 1427
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
1428 1429
		}

Y
Yan Zheng 已提交
1430
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1431 1432 1433 1434
				cur_offset, cur_offset + num_bytes - 1,
				locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
				EXTENT_SET_PRIVATE2);
Y
Yan Zheng 已提交
1435 1436 1437
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1438
	}
1439
	btrfs_release_path(path);
Y
Yan Zheng 已提交
1440

1441
	if (cur_offset <= end && cow_start == (u64)-1) {
Y
Yan Zheng 已提交
1442
		cow_start = cur_offset;
1443 1444 1445
		cur_offset = end;
	}

Y
Yan Zheng 已提交
1446
	if (cow_start != (u64)-1) {
1447 1448 1449
		ret = __cow_file_range(trans, inode, root, locked_page,
				       cow_start, end,
				       page_started, nr_written, 1);
1450 1451 1452 1453
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
Y
Yan Zheng 已提交
1454 1455
	}

1456
error:
1457
	err = btrfs_end_transaction(trans, root);
1458 1459 1460
	if (!ret)
		ret = err;

1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
	if (ret && cur_offset < end)
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     cur_offset, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);

1472
	btrfs_free_path(path);
1473
	return ret;
1474 1475
}

C
Chris Mason 已提交
1476 1477 1478
/*
 * extent_io.c call back to do delayed allocation processing
 */
C
Chris Mason 已提交
1479
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1480 1481
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1482 1483
{
	int ret;
1484
	struct btrfs_root *root = BTRFS_I(inode)->root;
1485

1486
	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
C
Chris Mason 已提交
1487
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1488
					 page_started, 1, nr_written);
1489
	} else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
Y
Yan Zheng 已提交
1490
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1491
					 page_started, 0, nr_written);
1492 1493 1494
	} else if (!btrfs_test_opt(root, COMPRESS) &&
		   !(BTRFS_I(inode)->force_compress) &&
		   !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
1495 1496
		ret = cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
1497 1498 1499
	} else {
		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
			&BTRFS_I(inode)->runtime_flags);
1500
		ret = cow_file_range_async(inode, locked_page, start, end,
C
Chris Mason 已提交
1501
					   page_started, nr_written);
1502
	}
1503 1504 1505
	return ret;
}

1506 1507
static void btrfs_split_extent_hook(struct inode *inode,
				    struct extent_state *orig, u64 split)
J
Josef Bacik 已提交
1508
{
1509
	/* not delalloc, ignore it */
J
Josef Bacik 已提交
1510
	if (!(orig->state & EXTENT_DELALLOC))
1511
		return;
J
Josef Bacik 已提交
1512

1513 1514 1515
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;
	spin_unlock(&BTRFS_I(inode)->lock);
J
Josef Bacik 已提交
1516 1517 1518 1519 1520 1521 1522 1523
}

/*
 * extent_io.c merge_extent_hook, used to track merged delayed allocation
 * extents so we can keep track of new extents that are just merged onto old
 * extents, such as when we are doing sequential writes, so we can properly
 * account for the metadata space we'll need.
 */
1524 1525 1526
static void btrfs_merge_extent_hook(struct inode *inode,
				    struct extent_state *new,
				    struct extent_state *other)
J
Josef Bacik 已提交
1527 1528 1529
{
	/* not delalloc, ignore it */
	if (!(other->state & EXTENT_DELALLOC))
1530
		return;
J
Josef Bacik 已提交
1531

1532 1533 1534
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents--;
	spin_unlock(&BTRFS_I(inode)->lock);
J
Josef Bacik 已提交
1535 1536
}

1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
static void btrfs_add_delalloc_inodes(struct btrfs_root *root,
				      struct inode *inode)
{
	spin_lock(&root->delalloc_lock);
	if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
		list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
			      &root->delalloc_inodes);
		set_bit(BTRFS_INODE_IN_DELALLOC_LIST,
			&BTRFS_I(inode)->runtime_flags);
		root->nr_delalloc_inodes++;
		if (root->nr_delalloc_inodes == 1) {
			spin_lock(&root->fs_info->delalloc_root_lock);
			BUG_ON(!list_empty(&root->delalloc_root));
			list_add_tail(&root->delalloc_root,
				      &root->fs_info->delalloc_roots);
			spin_unlock(&root->fs_info->delalloc_root_lock);
		}
	}
	spin_unlock(&root->delalloc_lock);
}

static void btrfs_del_delalloc_inode(struct btrfs_root *root,
				     struct inode *inode)
{
	spin_lock(&root->delalloc_lock);
	if (!list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
		list_del_init(&BTRFS_I(inode)->delalloc_inodes);
		clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
			  &BTRFS_I(inode)->runtime_flags);
		root->nr_delalloc_inodes--;
		if (!root->nr_delalloc_inodes) {
			spin_lock(&root->fs_info->delalloc_root_lock);
			BUG_ON(list_empty(&root->delalloc_root));
			list_del_init(&root->delalloc_root);
			spin_unlock(&root->fs_info->delalloc_root_lock);
		}
	}
	spin_unlock(&root->delalloc_lock);
}

C
Chris Mason 已提交
1577 1578 1579 1580 1581
/*
 * extent_io.c set_bit_hook, used to track delayed allocation
 * bytes in this file, and to maintain the list of inodes that
 * have pending delalloc work to be done.
 */
1582
static void btrfs_set_bit_hook(struct inode *inode,
1583
			       struct extent_state *state, unsigned long *bits)
1584
{
J
Josef Bacik 已提交
1585

1586 1587
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1588
	 * but in this case, we are only testing for the DELALLOC
1589 1590
	 * bit, which is only set or cleared with irqs on
	 */
1591
	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1592
		struct btrfs_root *root = BTRFS_I(inode)->root;
1593
		u64 len = state->end + 1 - state->start;
1594
		bool do_list = !btrfs_is_free_space_inode(inode);
J
Josef Bacik 已提交
1595

1596
		if (*bits & EXTENT_FIRST_DELALLOC) {
1597
			*bits &= ~EXTENT_FIRST_DELALLOC;
1598 1599 1600 1601 1602
		} else {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents++;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1603

1604 1605
		__percpu_counter_add(&root->fs_info->delalloc_bytes, len,
				     root->fs_info->delalloc_batch);
1606
		spin_lock(&BTRFS_I(inode)->lock);
1607
		BTRFS_I(inode)->delalloc_bytes += len;
1608
		if (do_list && !test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1609 1610
					 &BTRFS_I(inode)->runtime_flags))
			btrfs_add_delalloc_inodes(root, inode);
1611
		spin_unlock(&BTRFS_I(inode)->lock);
1612 1613 1614
	}
}

C
Chris Mason 已提交
1615 1616 1617
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1618
static void btrfs_clear_bit_hook(struct inode *inode,
1619 1620
				 struct extent_state *state,
				 unsigned long *bits)
1621
{
1622 1623
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1624
	 * but in this case, we are only testing for the DELALLOC
1625 1626
	 * bit, which is only set or cleared with irqs on
	 */
1627
	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1628
		struct btrfs_root *root = BTRFS_I(inode)->root;
1629
		u64 len = state->end + 1 - state->start;
1630
		bool do_list = !btrfs_is_free_space_inode(inode);
1631

1632
		if (*bits & EXTENT_FIRST_DELALLOC) {
1633
			*bits &= ~EXTENT_FIRST_DELALLOC;
1634 1635 1636 1637 1638
		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents--;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1639 1640 1641 1642

		if (*bits & EXTENT_DO_ACCOUNTING)
			btrfs_delalloc_release_metadata(inode, len);

J
Josef Bacik 已提交
1643 1644
		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
		    && do_list)
1645
			btrfs_free_reserved_data_space(inode, len);
J
Josef Bacik 已提交
1646

1647 1648
		__percpu_counter_add(&root->fs_info->delalloc_bytes, -len,
				     root->fs_info->delalloc_batch);
1649
		spin_lock(&BTRFS_I(inode)->lock);
1650
		BTRFS_I(inode)->delalloc_bytes -= len;
J
Josef Bacik 已提交
1651
		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1652
		    test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1653 1654
			     &BTRFS_I(inode)->runtime_flags))
			btrfs_del_delalloc_inode(root, inode);
1655
		spin_unlock(&BTRFS_I(inode)->lock);
1656 1657 1658
	}
}

C
Chris Mason 已提交
1659 1660 1661 1662
/*
 * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
 * we don't create bios that span stripes or chunks
 */
1663
int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
C
Chris Mason 已提交
1664 1665
			 size_t size, struct bio *bio,
			 unsigned long bio_flags)
1666 1667
{
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1668
	u64 logical = (u64)bio->bi_sector << 9;
1669 1670 1671 1672
	u64 length = 0;
	u64 map_length;
	int ret;

1673 1674 1675
	if (bio_flags & EXTENT_BIO_COMPRESSED)
		return 0;

1676
	length = bio->bi_size;
1677
	map_length = length;
1678
	ret = btrfs_map_block(root->fs_info, rw, logical,
1679
			      &map_length, NULL, 0);
1680
	/* Will always return 0 with map_multi == NULL */
1681
	BUG_ON(ret < 0);
C
Chris Mason 已提交
1682
	if (map_length < length + size)
1683
		return 1;
1684
	return 0;
1685 1686
}

C
Chris Mason 已提交
1687 1688 1689 1690 1691 1692 1693 1694
/*
 * in order to insert checksums into the metadata in large chunks,
 * we wait until bio submission time.   All the pages in the bio are
 * checksummed and sums are attached onto the ordered extent record.
 *
 * At IO completion time the cums attached on the ordered extent record
 * are inserted into the btree
 */
C
Chris Mason 已提交
1695 1696
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
1697 1698
				    unsigned long bio_flags,
				    u64 bio_offset)
1699 1700 1701
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1702

1703
	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1704
	BUG_ON(ret); /* -ENOMEM */
C
Chris Mason 已提交
1705 1706
	return 0;
}
1707

C
Chris Mason 已提交
1708 1709 1710 1711 1712 1713 1714 1715
/*
 * in order to insert checksums into the metadata in large chunks,
 * we wait until bio submission time.   All the pages in the bio are
 * checksummed and sums are attached onto the ordered extent record.
 *
 * At IO completion time the cums attached on the ordered extent record
 * are inserted into the btree
 */
1716
static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1717 1718
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
C
Chris Mason 已提交
1719 1720
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1721 1722 1723 1724 1725 1726
	int ret;

	ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
	if (ret)
		bio_endio(bio, ret);
	return ret;
1727 1728
}

C
Chris Mason 已提交
1729
/*
1730 1731
 * extent_io.c submission hook. This does the right thing for csum calculation
 * on write, or reading the csums from the tree before a read
C
Chris Mason 已提交
1732
 */
1733
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1734 1735
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1736 1737 1738
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1739
	int skip_sum;
1740
	int metadata = 0;
1741
	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1742

1743
	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1744

1745
	if (btrfs_is_free_space_inode(inode))
1746 1747
		metadata = 2;

1748
	if (!(rw & REQ_WRITE)) {
1749 1750
		ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
		if (ret)
1751
			goto out;
1752

1753
		if (bio_flags & EXTENT_BIO_COMPRESSED) {
1754 1755 1756 1757
			ret = btrfs_submit_compressed_read(inode, bio,
							   mirror_num,
							   bio_flags);
			goto out;
1758 1759 1760
		} else if (!skip_sum) {
			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
			if (ret)
1761
				goto out;
1762
		}
1763
		goto mapit;
1764
	} else if (async && !skip_sum) {
1765 1766 1767
		/* csum items have already been cloned */
		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
			goto mapit;
1768
		/* we're doing a write, do the async checksumming */
1769
		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1770
				   inode, rw, bio, mirror_num,
1771 1772
				   bio_flags, bio_offset,
				   __btrfs_submit_bio_start,
C
Chris Mason 已提交
1773
				   __btrfs_submit_bio_done);
1774
		goto out;
1775 1776 1777 1778
	} else if (!skip_sum) {
		ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
		if (ret)
			goto out;
1779 1780
	}

1781
mapit:
1782 1783 1784 1785 1786 1787
	ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);

out:
	if (ret < 0)
		bio_endio(bio, ret);
	return ret;
1788
}
C
Chris Mason 已提交
1789

C
Chris Mason 已提交
1790 1791 1792 1793
/*
 * given a list of ordered sums record them in the inode.  This happens
 * at IO completion time based on sums calculated at bio submission time.
 */
1794
static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1795 1796 1797 1798 1799
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

Q
Qinghuang Feng 已提交
1800
	list_for_each_entry(sum, list, list) {
M
Miao Xie 已提交
1801
		trans->adding_csums = 1;
1802 1803
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
M
Miao Xie 已提交
1804
		trans->adding_csums = 0;
1805 1806 1807 1808
	}
	return 0;
}

1809 1810
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
			      struct extent_state **cached_state)
1811
{
J
Julia Lawall 已提交
1812
	WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1813
	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1814
				   cached_state, GFP_NOFS);
1815 1816
}

C
Chris Mason 已提交
1817
/* see btrfs_writepage_start_hook for details on why this is required */
1818 1819 1820 1821 1822
struct btrfs_writepage_fixup {
	struct page *page;
	struct btrfs_work work;
};

1823
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1824 1825 1826
{
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_ordered_extent *ordered;
1827
	struct extent_state *cached_state = NULL;
1828 1829 1830 1831
	struct page *page;
	struct inode *inode;
	u64 page_start;
	u64 page_end;
1832
	int ret;
1833 1834 1835

	fixup = container_of(work, struct btrfs_writepage_fixup, work);
	page = fixup->page;
C
Chris Mason 已提交
1836
again:
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
	lock_page(page);
	if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
		ClearPageChecked(page);
		goto out_page;
	}

	inode = page->mapping->host;
	page_start = page_offset(page);
	page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;

1847
	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1848
			 &cached_state);
C
Chris Mason 已提交
1849 1850

	/* already ordered? We're done */
1851
	if (PagePrivate2(page))
1852
		goto out;
C
Chris Mason 已提交
1853 1854 1855

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
1856 1857
		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
				     page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
1858 1859
		unlock_page(page);
		btrfs_start_ordered_extent(inode, ordered, 1);
1860
		btrfs_put_ordered_extent(ordered);
C
Chris Mason 已提交
1861 1862
		goto again;
	}
1863

1864 1865 1866 1867 1868 1869 1870 1871
	ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
	if (ret) {
		mapping_set_error(page->mapping, ret);
		end_extent_writepage(page, ret, page_start, page_end);
		ClearPageChecked(page);
		goto out;
	 }

1872
	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1873
	ClearPageChecked(page);
1874
	set_page_dirty(page);
1875
out:
1876 1877
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
			     &cached_state, GFP_NOFS);
1878 1879 1880
out_page:
	unlock_page(page);
	page_cache_release(page);
1881
	kfree(fixup);
1882 1883 1884 1885 1886 1887 1888 1889
}

/*
 * There are a few paths in the higher layers of the kernel that directly
 * set the page dirty bit without asking the filesystem if it is a
 * good idea.  This causes problems because we want to make sure COW
 * properly happens and the data=ordered rules are followed.
 *
C
Chris Mason 已提交
1890
 * In our case any range that doesn't have the ORDERED bit set
1891 1892 1893 1894
 * hasn't been properly setup for IO.  We kick off an async process
 * to fix it up.  The async helper will wait for ordered extents, set
 * the delalloc bit and make it safe to write the page.
 */
1895
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1896 1897 1898 1899 1900
{
	struct inode *inode = page->mapping->host;
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_root *root = BTRFS_I(inode)->root;

1901 1902
	/* this page is properly in the ordered list */
	if (TestClearPagePrivate2(page))
1903 1904 1905 1906 1907 1908 1909 1910
		return 0;

	if (PageChecked(page))
		return -EAGAIN;

	fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
	if (!fixup)
		return -EAGAIN;
1911

1912 1913 1914 1915 1916
	SetPageChecked(page);
	page_cache_get(page);
	fixup->work.func = btrfs_writepage_fixup_worker;
	fixup->page = page;
	btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
1917
	return -EBUSY;
1918 1919
}

Y
Yan Zheng 已提交
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
				       struct inode *inode, u64 file_pos,
				       u64 disk_bytenr, u64 disk_num_bytes,
				       u64 num_bytes, u64 ram_bytes,
				       u8 compression, u8 encryption,
				       u16 other_encoding, int extent_type)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *fi;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key ins;
	int ret;

	path = btrfs_alloc_path();
1935 1936
	if (!path)
		return -ENOMEM;
Y
Yan Zheng 已提交
1937

1938
	path->leave_spinning = 1;
C
Chris Mason 已提交
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948

	/*
	 * we may be replacing one extent in the tree with another.
	 * The new extent is pinned in the extent map, and we don't want
	 * to drop it from the cache until it is completely in the btree.
	 *
	 * So, tell btrfs_drop_extents to leave this extent in the cache.
	 * the caller is expected to unpin it and allow it to be merged
	 * with the others.
	 */
J
Josef Bacik 已提交
1949
	ret = btrfs_drop_extents(trans, root, inode, file_pos,
1950
				 file_pos + num_bytes, 0);
1951 1952
	if (ret)
		goto out;
Y
Yan Zheng 已提交
1953

L
Li Zefan 已提交
1954
	ins.objectid = btrfs_ino(inode);
Y
Yan Zheng 已提交
1955 1956 1957
	ins.offset = file_pos;
	ins.type = BTRFS_EXTENT_DATA_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1958 1959
	if (ret)
		goto out;
Y
Yan Zheng 已提交
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
	leaf = path->nodes[0];
	fi = btrfs_item_ptr(leaf, path->slots[0],
			    struct btrfs_file_extent_item);
	btrfs_set_file_extent_generation(leaf, fi, trans->transid);
	btrfs_set_file_extent_type(leaf, fi, extent_type);
	btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
	btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
	btrfs_set_file_extent_offset(leaf, fi, 0);
	btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
	btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
	btrfs_set_file_extent_compression(leaf, fi, compression);
	btrfs_set_file_extent_encryption(leaf, fi, encryption);
	btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
1973

Y
Yan Zheng 已提交
1974
	btrfs_mark_buffer_dirty(leaf);
1975
	btrfs_release_path(path);
Y
Yan Zheng 已提交
1976 1977 1978 1979 1980 1981

	inode_add_bytes(inode, num_bytes);

	ins.objectid = disk_bytenr;
	ins.offset = disk_num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
1982 1983
	ret = btrfs_alloc_reserved_file_extent(trans, root,
					root->root_key.objectid,
L
Li Zefan 已提交
1984
					btrfs_ino(inode), file_pos, &ins);
1985
out:
Y
Yan Zheng 已提交
1986
	btrfs_free_path(path);
1987

1988
	return ret;
Y
Yan Zheng 已提交
1989 1990
}

L
Liu Bo 已提交
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
/* snapshot-aware defrag */
struct sa_defrag_extent_backref {
	struct rb_node node;
	struct old_sa_defrag_extent *old;
	u64 root_id;
	u64 inum;
	u64 file_pos;
	u64 extent_offset;
	u64 num_bytes;
	u64 generation;
};

struct old_sa_defrag_extent {
	struct list_head list;
	struct new_sa_defrag_extent *new;

	u64 extent_offset;
	u64 bytenr;
	u64 offset;
	u64 len;
	int count;
};

struct new_sa_defrag_extent {
	struct rb_root root;
	struct list_head head;
	struct btrfs_path *path;
	struct inode *inode;
	u64 file_pos;
	u64 len;
	u64 bytenr;
	u64 disk_len;
	u8 compress_type;
};

static int backref_comp(struct sa_defrag_extent_backref *b1,
			struct sa_defrag_extent_backref *b2)
{
	if (b1->root_id < b2->root_id)
		return -1;
	else if (b1->root_id > b2->root_id)
		return 1;

	if (b1->inum < b2->inum)
		return -1;
	else if (b1->inum > b2->inum)
		return 1;

	if (b1->file_pos < b2->file_pos)
		return -1;
	else if (b1->file_pos > b2->file_pos)
		return 1;

	/*
	 * [------------------------------] ===> (a range of space)
	 *     |<--->|   |<---->| =============> (fs/file tree A)
	 * |<---------------------------->| ===> (fs/file tree B)
	 *
	 * A range of space can refer to two file extents in one tree while
	 * refer to only one file extent in another tree.
	 *
	 * So we may process a disk offset more than one time(two extents in A)
	 * and locate at the same extent(one extent in B), then insert two same
	 * backrefs(both refer to the extent in B).
	 */
	return 0;
}

static void backref_insert(struct rb_root *root,
			   struct sa_defrag_extent_backref *backref)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sa_defrag_extent_backref *entry;
	int ret;

	while (*p) {
		parent = *p;
		entry = rb_entry(parent, struct sa_defrag_extent_backref, node);

		ret = backref_comp(backref, entry);
		if (ret < 0)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	rb_link_node(&backref->node, parent, p);
	rb_insert_color(&backref->node, root);
}

/*
 * Note the backref might has changed, and in this case we just return 0.
 */
static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
				       void *ctx)
{
	struct btrfs_file_extent_item *extent;
	struct btrfs_fs_info *fs_info;
	struct old_sa_defrag_extent *old = ctx;
	struct new_sa_defrag_extent *new = old->new;
	struct btrfs_path *path = new->path;
	struct btrfs_key key;
	struct btrfs_root *root;
	struct sa_defrag_extent_backref *backref;
	struct extent_buffer *leaf;
	struct inode *inode = new->inode;
	int slot;
	int ret;
	u64 extent_offset;
	u64 num_bytes;

	if (BTRFS_I(inode)->root->root_key.objectid == root_id &&
	    inum == btrfs_ino(inode))
		return 0;

	key.objectid = root_id;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = (u64)-1;

	fs_info = BTRFS_I(inode)->root->fs_info;
	root = btrfs_read_fs_root_no_name(fs_info, &key);
	if (IS_ERR(root)) {
		if (PTR_ERR(root) == -ENOENT)
			return 0;
		WARN_ON(1);
		pr_debug("inum=%llu, offset=%llu, root_id=%llu\n",
			 inum, offset, root_id);
		return PTR_ERR(root);
	}

	key.objectid = inum;
	key.type = BTRFS_EXTENT_DATA_KEY;
	if (offset > (u64)-1 << 32)
		key.offset = 0;
	else
		key.offset = offset;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0) {
		WARN_ON(1);
		return ret;
	}

	while (1) {
		cond_resched();

		leaf = path->nodes[0];
		slot = path->slots[0];

		if (slot >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0) {
				goto out;
			} else if (ret > 0) {
				ret = 0;
				goto out;
			}
			continue;
		}

		path->slots[0]++;

		btrfs_item_key_to_cpu(leaf, &key, slot);

		if (key.objectid > inum)
			goto out;

		if (key.objectid < inum || key.type != BTRFS_EXTENT_DATA_KEY)
			continue;

		extent = btrfs_item_ptr(leaf, slot,
					struct btrfs_file_extent_item);

		if (btrfs_file_extent_disk_bytenr(leaf, extent) != old->bytenr)
			continue;

		extent_offset = btrfs_file_extent_offset(leaf, extent);
		if (key.offset - extent_offset != offset)
			continue;

		num_bytes = btrfs_file_extent_num_bytes(leaf, extent);
		if (extent_offset >= old->extent_offset + old->offset +
		    old->len || extent_offset + num_bytes <=
		    old->extent_offset + old->offset)
			continue;

		break;
	}

	backref = kmalloc(sizeof(*backref), GFP_NOFS);
	if (!backref) {
		ret = -ENOENT;
		goto out;
	}

	backref->root_id = root_id;
	backref->inum = inum;
	backref->file_pos = offset + extent_offset;
	backref->num_bytes = num_bytes;
	backref->extent_offset = extent_offset;
	backref->generation = btrfs_file_extent_generation(leaf, extent);
	backref->old = old;
	backref_insert(&new->root, backref);
	old->count++;
out:
	btrfs_release_path(path);
	WARN_ON(ret);
	return ret;
}

static noinline bool record_extent_backrefs(struct btrfs_path *path,
				   struct new_sa_defrag_extent *new)
{
	struct btrfs_fs_info *fs_info = BTRFS_I(new->inode)->root->fs_info;
	struct old_sa_defrag_extent *old, *tmp;
	int ret;

	new->path = path;

	list_for_each_entry_safe(old, tmp, &new->head, list) {
		ret = iterate_inodes_from_logical(old->bytenr, fs_info,
						  path, record_one_backref,
						  old);
		BUG_ON(ret < 0 && ret != -ENOENT);

		/* no backref to be processed for this extent */
		if (!old->count) {
			list_del(&old->list);
			kfree(old);
		}
	}

	if (list_empty(&new->head))
		return false;

	return true;
}

static int relink_is_mergable(struct extent_buffer *leaf,
			      struct btrfs_file_extent_item *fi,
			      u64 disk_bytenr)
{
	if (btrfs_file_extent_disk_bytenr(leaf, fi) != disk_bytenr)
		return 0;

	if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
		return 0;

	if (btrfs_file_extent_compression(leaf, fi) ||
	    btrfs_file_extent_encryption(leaf, fi) ||
	    btrfs_file_extent_other_encoding(leaf, fi))
		return 0;

	return 1;
}

/*
 * Note the backref might has changed, and in this case we just return 0.
 */
static noinline int relink_extent_backref(struct btrfs_path *path,
				 struct sa_defrag_extent_backref *prev,
				 struct sa_defrag_extent_backref *backref)
{
	struct btrfs_file_extent_item *extent;
	struct btrfs_file_extent_item *item;
	struct btrfs_ordered_extent *ordered;
	struct btrfs_trans_handle *trans;
	struct btrfs_fs_info *fs_info;
	struct btrfs_root *root;
	struct btrfs_key key;
	struct extent_buffer *leaf;
	struct old_sa_defrag_extent *old = backref->old;
	struct new_sa_defrag_extent *new = old->new;
	struct inode *src_inode = new->inode;
	struct inode *inode;
	struct extent_state *cached = NULL;
	int ret = 0;
	u64 start;
	u64 len;
	u64 lock_start;
	u64 lock_end;
	bool merge = false;
	int index;

	if (prev && prev->root_id == backref->root_id &&
	    prev->inum == backref->inum &&
	    prev->file_pos + prev->num_bytes == backref->file_pos)
		merge = true;

	/* step 1: get root */
	key.objectid = backref->root_id;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = (u64)-1;

	fs_info = BTRFS_I(src_inode)->root->fs_info;
	index = srcu_read_lock(&fs_info->subvol_srcu);

	root = btrfs_read_fs_root_no_name(fs_info, &key);
	if (IS_ERR(root)) {
		srcu_read_unlock(&fs_info->subvol_srcu, index);
		if (PTR_ERR(root) == -ENOENT)
			return 0;
		return PTR_ERR(root);
	}

	/* step 2: get inode */
	key.objectid = backref->inum;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;

	inode = btrfs_iget(fs_info->sb, &key, root, NULL);
	if (IS_ERR(inode)) {
		srcu_read_unlock(&fs_info->subvol_srcu, index);
		return 0;
	}

	srcu_read_unlock(&fs_info->subvol_srcu, index);

	/* step 3: relink backref */
	lock_start = backref->file_pos;
	lock_end = backref->file_pos + backref->num_bytes - 1;
	lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
			 0, &cached);

	ordered = btrfs_lookup_first_ordered_extent(inode, lock_end);
	if (ordered) {
		btrfs_put_ordered_extent(ordered);
		goto out_unlock;
	}

	trans = btrfs_join_transaction(root);
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto out_unlock;
	}

	key.objectid = backref->inum;
	key.type = BTRFS_EXTENT_DATA_KEY;
	key.offset = backref->file_pos;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0) {
		goto out_free_path;
	} else if (ret > 0) {
		ret = 0;
		goto out_free_path;
	}

	extent = btrfs_item_ptr(path->nodes[0], path->slots[0],
				struct btrfs_file_extent_item);

	if (btrfs_file_extent_generation(path->nodes[0], extent) !=
	    backref->generation)
		goto out_free_path;

	btrfs_release_path(path);

	start = backref->file_pos;
	if (backref->extent_offset < old->extent_offset + old->offset)
		start += old->extent_offset + old->offset -
			 backref->extent_offset;

	len = min(backref->extent_offset + backref->num_bytes,
		  old->extent_offset + old->offset + old->len);
	len -= max(backref->extent_offset, old->extent_offset + old->offset);

	ret = btrfs_drop_extents(trans, root, inode, start,
				 start + len, 1);
	if (ret)
		goto out_free_path;
again:
	key.objectid = btrfs_ino(inode);
	key.type = BTRFS_EXTENT_DATA_KEY;
	key.offset = start;

2367
	path->leave_spinning = 1;
L
Liu Bo 已提交
2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423
	if (merge) {
		struct btrfs_file_extent_item *fi;
		u64 extent_len;
		struct btrfs_key found_key;

		ret = btrfs_search_slot(trans, root, &key, path, 1, 1);
		if (ret < 0)
			goto out_free_path;

		path->slots[0]--;
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

		fi = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);
		extent_len = btrfs_file_extent_num_bytes(leaf, fi);

		if (relink_is_mergable(leaf, fi, new->bytenr) &&
		    extent_len + found_key.offset == start) {
			btrfs_set_file_extent_num_bytes(leaf, fi,
							extent_len + len);
			btrfs_mark_buffer_dirty(leaf);
			inode_add_bytes(inode, len);

			ret = 1;
			goto out_free_path;
		} else {
			merge = false;
			btrfs_release_path(path);
			goto again;
		}
	}

	ret = btrfs_insert_empty_item(trans, root, path, &key,
					sizeof(*extent));
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_free_path;
	}

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
				struct btrfs_file_extent_item);
	btrfs_set_file_extent_disk_bytenr(leaf, item, new->bytenr);
	btrfs_set_file_extent_disk_num_bytes(leaf, item, new->disk_len);
	btrfs_set_file_extent_offset(leaf, item, start - new->file_pos);
	btrfs_set_file_extent_num_bytes(leaf, item, len);
	btrfs_set_file_extent_ram_bytes(leaf, item, new->len);
	btrfs_set_file_extent_generation(leaf, item, trans->transid);
	btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
	btrfs_set_file_extent_compression(leaf, item, new->compress_type);
	btrfs_set_file_extent_encryption(leaf, item, 0);
	btrfs_set_file_extent_other_encoding(leaf, item, 0);

	btrfs_mark_buffer_dirty(leaf);
	inode_add_bytes(inode, len);
2424
	btrfs_release_path(path);
L
Liu Bo 已提交
2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437

	ret = btrfs_inc_extent_ref(trans, root, new->bytenr,
			new->disk_len, 0,
			backref->root_id, backref->inum,
			new->file_pos, 0);	/* start - extent_offset */
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_free_path;
	}

	ret = 1;
out_free_path:
	btrfs_release_path(path);
2438
	path->leave_spinning = 0;
L
Liu Bo 已提交
2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622
	btrfs_end_transaction(trans, root);
out_unlock:
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
			     &cached, GFP_NOFS);
	iput(inode);
	return ret;
}

static void relink_file_extents(struct new_sa_defrag_extent *new)
{
	struct btrfs_path *path;
	struct old_sa_defrag_extent *old, *tmp;
	struct sa_defrag_extent_backref *backref;
	struct sa_defrag_extent_backref *prev = NULL;
	struct inode *inode;
	struct btrfs_root *root;
	struct rb_node *node;
	int ret;

	inode = new->inode;
	root = BTRFS_I(inode)->root;

	path = btrfs_alloc_path();
	if (!path)
		return;

	if (!record_extent_backrefs(path, new)) {
		btrfs_free_path(path);
		goto out;
	}
	btrfs_release_path(path);

	while (1) {
		node = rb_first(&new->root);
		if (!node)
			break;
		rb_erase(node, &new->root);

		backref = rb_entry(node, struct sa_defrag_extent_backref, node);

		ret = relink_extent_backref(path, prev, backref);
		WARN_ON(ret < 0);

		kfree(prev);

		if (ret == 1)
			prev = backref;
		else
			prev = NULL;
		cond_resched();
	}
	kfree(prev);

	btrfs_free_path(path);

	list_for_each_entry_safe(old, tmp, &new->head, list) {
		list_del(&old->list);
		kfree(old);
	}
out:
	atomic_dec(&root->fs_info->defrag_running);
	wake_up(&root->fs_info->transaction_wait);

	kfree(new);
}

static struct new_sa_defrag_extent *
record_old_file_extents(struct inode *inode,
			struct btrfs_ordered_extent *ordered)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_path *path;
	struct btrfs_key key;
	struct old_sa_defrag_extent *old, *tmp;
	struct new_sa_defrag_extent *new;
	int ret;

	new = kmalloc(sizeof(*new), GFP_NOFS);
	if (!new)
		return NULL;

	new->inode = inode;
	new->file_pos = ordered->file_offset;
	new->len = ordered->len;
	new->bytenr = ordered->start;
	new->disk_len = ordered->disk_len;
	new->compress_type = ordered->compress_type;
	new->root = RB_ROOT;
	INIT_LIST_HEAD(&new->head);

	path = btrfs_alloc_path();
	if (!path)
		goto out_kfree;

	key.objectid = btrfs_ino(inode);
	key.type = BTRFS_EXTENT_DATA_KEY;
	key.offset = new->file_pos;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto out_free_path;
	if (ret > 0 && path->slots[0] > 0)
		path->slots[0]--;

	/* find out all the old extents for the file range */
	while (1) {
		struct btrfs_file_extent_item *extent;
		struct extent_buffer *l;
		int slot;
		u64 num_bytes;
		u64 offset;
		u64 end;
		u64 disk_bytenr;
		u64 extent_offset;

		l = path->nodes[0];
		slot = path->slots[0];

		if (slot >= btrfs_header_nritems(l)) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto out_free_list;
			else if (ret > 0)
				break;
			continue;
		}

		btrfs_item_key_to_cpu(l, &key, slot);

		if (key.objectid != btrfs_ino(inode))
			break;
		if (key.type != BTRFS_EXTENT_DATA_KEY)
			break;
		if (key.offset >= new->file_pos + new->len)
			break;

		extent = btrfs_item_ptr(l, slot, struct btrfs_file_extent_item);

		num_bytes = btrfs_file_extent_num_bytes(l, extent);
		if (key.offset + num_bytes < new->file_pos)
			goto next;

		disk_bytenr = btrfs_file_extent_disk_bytenr(l, extent);
		if (!disk_bytenr)
			goto next;

		extent_offset = btrfs_file_extent_offset(l, extent);

		old = kmalloc(sizeof(*old), GFP_NOFS);
		if (!old)
			goto out_free_list;

		offset = max(new->file_pos, key.offset);
		end = min(new->file_pos + new->len, key.offset + num_bytes);

		old->bytenr = disk_bytenr;
		old->extent_offset = extent_offset;
		old->offset = offset - key.offset;
		old->len = end - offset;
		old->new = new;
		old->count = 0;
		list_add_tail(&old->list, &new->head);
next:
		path->slots[0]++;
		cond_resched();
	}

	btrfs_free_path(path);
	atomic_inc(&root->fs_info->defrag_running);

	return new;

out_free_list:
	list_for_each_entry_safe(old, tmp, &new->head, list) {
		list_del(&old->list);
		kfree(old);
	}
out_free_path:
	btrfs_free_path(path);
out_kfree:
	kfree(new);
	return NULL;
}

2623 2624 2625 2626 2627 2628
/*
 * helper function for btrfs_finish_ordered_io, this
 * just reads in some of the csum leaves to prime them into ram
 * before we start the transaction.  It limits the amount of btree
 * reads required while inside the transaction.
 */
C
Chris Mason 已提交
2629 2630 2631 2632
/* as ordered data IO finishes, this gets called so we can finish
 * an ordered extent if the range of bytes in the file it covers are
 * fully written.
 */
2633
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2634
{
2635
	struct inode *inode = ordered_extent->inode;
2636
	struct btrfs_root *root = BTRFS_I(inode)->root;
2637
	struct btrfs_trans_handle *trans = NULL;
2638
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2639
	struct extent_state *cached_state = NULL;
L
Liu Bo 已提交
2640
	struct new_sa_defrag_extent *new = NULL;
2641
	int compress_type = 0;
2642
	int ret;
2643
	bool nolock;
2644

2645
	nolock = btrfs_is_free_space_inode(inode);
J
Josef Bacik 已提交
2646

2647 2648 2649 2650 2651
	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
		ret = -EIO;
		goto out;
	}

2652
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
2653
		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
2654 2655 2656 2657 2658 2659 2660 2661 2662
		btrfs_ordered_update_i_size(inode, 0, ordered_extent);
		if (nolock)
			trans = btrfs_join_transaction_nolock(root);
		else
			trans = btrfs_join_transaction(root);
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
			trans = NULL;
			goto out;
2663
		}
2664 2665 2666 2667
		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
		ret = btrfs_update_inode_fallback(trans, root, inode);
		if (ret) /* -ENOMEM or corruption */
			btrfs_abort_transaction(trans, root, ret);
2668 2669
		goto out;
	}
2670

2671 2672
	lock_extent_bits(io_tree, ordered_extent->file_offset,
			 ordered_extent->file_offset + ordered_extent->len - 1,
2673
			 0, &cached_state);
2674

L
Liu Bo 已提交
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688
	ret = test_range_bit(io_tree, ordered_extent->file_offset,
			ordered_extent->file_offset + ordered_extent->len - 1,
			EXTENT_DEFRAG, 1, cached_state);
	if (ret) {
		u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item);
		if (last_snapshot >= BTRFS_I(inode)->generation)
			/* the inode is shared */
			new = record_old_file_extents(inode, ordered_extent);

		clear_extent_bit(io_tree, ordered_extent->file_offset,
			ordered_extent->file_offset + ordered_extent->len - 1,
			EXTENT_DEFRAG, 0, 0, &cached_state, GFP_NOFS);
	}

J
Josef Bacik 已提交
2689
	if (nolock)
2690
		trans = btrfs_join_transaction_nolock(root);
J
Josef Bacik 已提交
2691
	else
2692
		trans = btrfs_join_transaction(root);
2693 2694 2695 2696 2697
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		trans = NULL;
		goto out_unlock;
	}
2698
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2699

C
Chris Mason 已提交
2700
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
2701
		compress_type = ordered_extent->compress_type;
Y
Yan Zheng 已提交
2702
	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
2703
		BUG_ON(compress_type);
Y
Yan, Zheng 已提交
2704
		ret = btrfs_mark_extent_written(trans, inode,
Y
Yan Zheng 已提交
2705 2706 2707 2708
						ordered_extent->file_offset,
						ordered_extent->file_offset +
						ordered_extent->len);
	} else {
2709
		BUG_ON(root == root->fs_info->tree_root);
Y
Yan Zheng 已提交
2710 2711 2712 2713 2714 2715
		ret = insert_reserved_file_extent(trans, inode,
						ordered_extent->file_offset,
						ordered_extent->start,
						ordered_extent->disk_len,
						ordered_extent->len,
						ordered_extent->len,
2716
						compress_type, 0, 0,
Y
Yan Zheng 已提交
2717 2718
						BTRFS_FILE_EXTENT_REG);
	}
J
Josef Bacik 已提交
2719 2720 2721
	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
			   ordered_extent->file_offset, ordered_extent->len,
			   trans->transid);
2722 2723
	if (ret < 0) {
		btrfs_abort_transaction(trans, root, ret);
2724
		goto out_unlock;
2725
	}
2726

2727 2728 2729
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

2730 2731 2732 2733 2734
	btrfs_ordered_update_i_size(inode, 0, ordered_extent);
	ret = btrfs_update_inode_fallback(trans, root, inode);
	if (ret) { /* -ENOMEM or corruption */
		btrfs_abort_transaction(trans, root, ret);
		goto out_unlock;
2735 2736
	}
	ret = 0;
2737 2738 2739 2740
out_unlock:
	unlock_extent_cached(io_tree, ordered_extent->file_offset,
			     ordered_extent->file_offset +
			     ordered_extent->len - 1, &cached_state, GFP_NOFS);
2741
out:
2742
	if (root != root->fs_info->tree_root)
J
Josef Bacik 已提交
2743
		btrfs_delalloc_release_metadata(inode, ordered_extent->len);
2744 2745
	if (trans)
		btrfs_end_transaction(trans, root);
J
Josef Bacik 已提交
2746

2747
	if (ret) {
2748 2749 2750 2751
		clear_extent_uptodate(io_tree, ordered_extent->file_offset,
				      ordered_extent->file_offset +
				      ordered_extent->len - 1, NULL, GFP_NOFS);

2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
		/*
		 * If the ordered extent had an IOERR or something else went
		 * wrong we need to return the space for this ordered extent
		 * back to the allocator.
		 */
		if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags))
			btrfs_free_reserved_extent(root, ordered_extent->start,
						   ordered_extent->disk_len);
	}


2764
	/*
2765 2766
	 * This needs to be done to make sure anybody waiting knows we are done
	 * updating everything for this ordered extent.
2767 2768 2769
	 */
	btrfs_remove_ordered_extent(inode, ordered_extent);

L
Liu Bo 已提交
2770 2771 2772 2773
	/* for snapshot-aware defrag */
	if (new)
		relink_file_extents(new);

2774 2775 2776 2777 2778
	/* once for us */
	btrfs_put_ordered_extent(ordered_extent);
	/* once for the tree */
	btrfs_put_ordered_extent(ordered_extent);

2779 2780 2781 2782 2783 2784 2785 2786
	return ret;
}

static void finish_ordered_fn(struct btrfs_work *work)
{
	struct btrfs_ordered_extent *ordered_extent;
	ordered_extent = container_of(work, struct btrfs_ordered_extent, work);
	btrfs_finish_ordered_io(ordered_extent);
2787 2788
}

2789
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2790 2791
				struct extent_state *state, int uptodate)
{
2792 2793 2794 2795 2796
	struct inode *inode = page->mapping->host;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_ordered_extent *ordered_extent = NULL;
	struct btrfs_workers *workers;

2797 2798
	trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);

2799
	ClearPagePrivate2(page);
2800 2801 2802 2803 2804 2805 2806
	if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
					    end - start + 1, uptodate))
		return 0;

	ordered_extent->work.func = finish_ordered_fn;
	ordered_extent->work.flags = 0;

2807
	if (btrfs_is_free_space_inode(inode))
2808 2809 2810 2811 2812 2813
		workers = &root->fs_info->endio_freespace_worker;
	else
		workers = &root->fs_info->endio_write_workers;
	btrfs_queue_worker(workers, &ordered_extent->work);

	return 0;
2814 2815
}

C
Chris Mason 已提交
2816 2817
/*
 * when reads are done, we need to check csums to verify the data is correct
2818 2819
 * if there's a match, we allow the bio to finish.  If not, the code in
 * extent_io.c will try to find good copies for us.
C
Chris Mason 已提交
2820
 */
2821
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
2822
			       struct extent_state *state, int mirror)
2823
{
M
Miao Xie 已提交
2824
	size_t offset = start - page_offset(page);
2825
	struct inode *inode = page->mapping->host;
2826
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2827
	char *kaddr;
2828
	u64 private = ~(u32)0;
2829
	int ret;
2830 2831
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
2832 2833
	static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
	                              DEFAULT_RATELIMIT_BURST);
2834

2835 2836 2837 2838
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
2839 2840

	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
2841
		goto good;
2842 2843

	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
2844
	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
2845 2846
		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
				  GFP_NOFS);
2847
		return 0;
2848
	}
2849

Y
Yan 已提交
2850
	if (state && state->start == start) {
2851 2852 2853 2854 2855
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
2856
	kaddr = kmap_atomic(page);
C
Chris Mason 已提交
2857
	if (ret)
2858
		goto zeroit;
C
Chris Mason 已提交
2859

2860
	csum = btrfs_csum_data(kaddr + offset, csum,  end - start + 1);
2861
	btrfs_csum_final(csum, (char *)&csum);
C
Chris Mason 已提交
2862
	if (csum != private)
2863
		goto zeroit;
C
Chris Mason 已提交
2864

2865
	kunmap_atomic(kaddr);
2866
good:
2867 2868 2869
	return 0;

zeroit:
2870 2871 2872 2873 2874
	if (__ratelimit(&_rs))
		btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u private %llu",
			(unsigned long long)btrfs_ino(page->mapping->host),
			(unsigned long long)start, csum,
			(unsigned long long)private);
2875 2876
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
2877
	kunmap_atomic(kaddr);
2878 2879
	if (private == 0)
		return 0;
2880
	return -EIO;
2881
}
2882

Y
Yan, Zheng 已提交
2883 2884 2885 2886 2887
struct delayed_iput {
	struct list_head list;
	struct inode *inode;
};

2888 2889
/* JDM: If this is fs-wide, why can't we add a pointer to
 * btrfs_inode instead and avoid the allocation? */
Y
Yan, Zheng 已提交
2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930
void btrfs_add_delayed_iput(struct inode *inode)
{
	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
	struct delayed_iput *delayed;

	if (atomic_add_unless(&inode->i_count, -1, 1))
		return;

	delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
	delayed->inode = inode;

	spin_lock(&fs_info->delayed_iput_lock);
	list_add_tail(&delayed->list, &fs_info->delayed_iputs);
	spin_unlock(&fs_info->delayed_iput_lock);
}

void btrfs_run_delayed_iputs(struct btrfs_root *root)
{
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct delayed_iput *delayed;
	int empty;

	spin_lock(&fs_info->delayed_iput_lock);
	empty = list_empty(&fs_info->delayed_iputs);
	spin_unlock(&fs_info->delayed_iput_lock);
	if (empty)
		return;

	spin_lock(&fs_info->delayed_iput_lock);
	list_splice_init(&fs_info->delayed_iputs, &list);
	spin_unlock(&fs_info->delayed_iput_lock);

	while (!list_empty(&list)) {
		delayed = list_entry(list.next, struct delayed_iput, list);
		list_del(&delayed->list);
		iput(delayed->inode);
		kfree(delayed);
	}
}

2931
/*
2932
 * This is called in transaction commit time. If there are no orphan
2933 2934 2935 2936 2937 2938
 * files in the subvolume, it removes orphan item and frees block_rsv
 * structure.
 */
void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root)
{
2939
	struct btrfs_block_rsv *block_rsv;
2940 2941
	int ret;

2942
	if (atomic_read(&root->orphan_inodes) ||
2943 2944 2945
	    root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
		return;

2946
	spin_lock(&root->orphan_lock);
2947
	if (atomic_read(&root->orphan_inodes)) {
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
		spin_unlock(&root->orphan_lock);
		return;
	}

	if (root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) {
		spin_unlock(&root->orphan_lock);
		return;
	}

	block_rsv = root->orphan_block_rsv;
	root->orphan_block_rsv = NULL;
	spin_unlock(&root->orphan_lock);

2961 2962 2963 2964 2965 2966 2967 2968
	if (root->orphan_item_inserted &&
	    btrfs_root_refs(&root->root_item) > 0) {
		ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
					    root->root_key.objectid);
		BUG_ON(ret);
		root->orphan_item_inserted = 0;
	}

2969 2970 2971
	if (block_rsv) {
		WARN_ON(block_rsv->size > 0);
		btrfs_free_block_rsv(root, block_rsv);
2972 2973 2974
	}
}

2975 2976 2977
/*
 * This creates an orphan entry for the given inode in case something goes
 * wrong in the middle of an unlink/truncate.
2978 2979 2980
 *
 * NOTE: caller of this function should reserve 5 units of metadata for
 *	 this function.
2981 2982 2983 2984
 */
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
2985 2986 2987 2988
	struct btrfs_block_rsv *block_rsv = NULL;
	int reserve = 0;
	int insert = 0;
	int ret;
2989

2990
	if (!root->orphan_block_rsv) {
2991
		block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
2992 2993
		if (!block_rsv)
			return -ENOMEM;
2994
	}
2995

2996 2997 2998 2999 3000 3001
	spin_lock(&root->orphan_lock);
	if (!root->orphan_block_rsv) {
		root->orphan_block_rsv = block_rsv;
	} else if (block_rsv) {
		btrfs_free_block_rsv(root, block_rsv);
		block_rsv = NULL;
3002 3003
	}

3004 3005
	if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			      &BTRFS_I(inode)->runtime_flags)) {
3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017
#if 0
		/*
		 * For proper ENOSPC handling, we should do orphan
		 * cleanup when mounting. But this introduces backward
		 * compatibility issue.
		 */
		if (!xchg(&root->orphan_item_inserted, 1))
			insert = 2;
		else
			insert = 1;
#endif
		insert = 1;
3018
		atomic_inc(&root->orphan_inodes);
3019 3020
	}

3021 3022
	if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			      &BTRFS_I(inode)->runtime_flags))
3023 3024
		reserve = 1;
	spin_unlock(&root->orphan_lock);
3025

3026 3027 3028
	/* grab metadata reservation from transaction handle */
	if (reserve) {
		ret = btrfs_orphan_reserve_metadata(trans, inode);
3029
		BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */
3030
	}
3031

3032 3033
	/* insert an orphan item to track this unlinked/truncated file */
	if (insert >= 1) {
L
Li Zefan 已提交
3034
		ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
3035
		if (ret && ret != -EEXIST) {
3036 3037
			clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
				  &BTRFS_I(inode)->runtime_flags);
3038 3039 3040 3041
			btrfs_abort_transaction(trans, root, ret);
			return ret;
		}
		ret = 0;
3042 3043 3044 3045 3046 3047
	}

	/* insert an orphan item to track subvolume contains orphan files */
	if (insert >= 2) {
		ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
					       root->root_key.objectid);
3048 3049 3050 3051
		if (ret && ret != -EEXIST) {
			btrfs_abort_transaction(trans, root, ret);
			return ret;
		}
3052 3053
	}
	return 0;
3054 3055 3056 3057 3058 3059
}

/*
 * We have done the truncate/delete so we can go ahead and remove the orphan
 * item for this particular inode.
 */
3060 3061
static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
			    struct inode *inode)
3062 3063
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
3064 3065
	int delete_item = 0;
	int release_rsv = 0;
3066 3067
	int ret = 0;

3068
	spin_lock(&root->orphan_lock);
3069 3070
	if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			       &BTRFS_I(inode)->runtime_flags))
3071
		delete_item = 1;
3072

3073 3074
	if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			       &BTRFS_I(inode)->runtime_flags))
3075 3076
		release_rsv = 1;
	spin_unlock(&root->orphan_lock);
3077

3078
	if (trans && delete_item) {
L
Li Zefan 已提交
3079
		ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
3080
		BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
3081
	}
3082

3083
	if (release_rsv) {
3084
		btrfs_orphan_release_metadata(inode);
3085 3086
		atomic_dec(&root->orphan_inodes);
	}
3087

3088
	return 0;
3089 3090 3091 3092 3093 3094
}

/*
 * this cleans up any orphans that may be left on the list from the last use
 * of this root.
 */
3095
int btrfs_orphan_cleanup(struct btrfs_root *root)
3096 3097 3098 3099 3100 3101
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key, found_key;
	struct btrfs_trans_handle *trans;
	struct inode *inode;
3102
	u64 last_objectid = 0;
3103 3104
	int ret = 0, nr_unlink = 0, nr_truncate = 0;

3105
	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
3106
		return 0;
3107 3108

	path = btrfs_alloc_path();
3109 3110 3111 3112
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}
3113 3114 3115 3116 3117 3118 3119 3120
	path->reada = -1;

	key.objectid = BTRFS_ORPHAN_OBJECTID;
	btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
	key.offset = (u64)-1;

	while (1) {
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3121 3122
		if (ret < 0)
			goto out;
3123 3124 3125

		/*
		 * if ret == 0 means we found what we were searching for, which
L
Lucas De Marchi 已提交
3126
		 * is weird, but possible, so only screw with path if we didn't
3127 3128 3129
		 * find the key and see if we have stuff that matches
		 */
		if (ret > 0) {
3130
			ret = 0;
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146
			if (path->slots[0] == 0)
				break;
			path->slots[0]--;
		}

		/* pull out the item */
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

		/* make sure the item matches what we want */
		if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
			break;
		if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
			break;

		/* release the path since we're done with it */
3147
		btrfs_release_path(path);
3148 3149 3150 3151 3152 3153

		/*
		 * this is where we are basically btrfs_lookup, without the
		 * crossing root thing.  we store the inode number in the
		 * offset of the orphan item.
		 */
3154 3155

		if (found_key.offset == last_objectid) {
3156 3157
			btrfs_err(root->fs_info,
				"Error removing orphan entry, stopping orphan cleanup");
3158 3159 3160 3161 3162 3163
			ret = -EINVAL;
			goto out;
		}

		last_objectid = found_key.offset;

3164 3165 3166
		found_key.objectid = found_key.offset;
		found_key.type = BTRFS_INODE_ITEM_KEY;
		found_key.offset = 0;
3167
		inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
J
Josef Bacik 已提交
3168 3169
		ret = PTR_RET(inode);
		if (ret && ret != -ESTALE)
3170
			goto out;
3171

3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203
		if (ret == -ESTALE && root == root->fs_info->tree_root) {
			struct btrfs_root *dead_root;
			struct btrfs_fs_info *fs_info = root->fs_info;
			int is_dead_root = 0;

			/*
			 * this is an orphan in the tree root. Currently these
			 * could come from 2 sources:
			 *  a) a snapshot deletion in progress
			 *  b) a free space cache inode
			 * We need to distinguish those two, as the snapshot
			 * orphan must not get deleted.
			 * find_dead_roots already ran before us, so if this
			 * is a snapshot deletion, we should find the root
			 * in the dead_roots list
			 */
			spin_lock(&fs_info->trans_lock);
			list_for_each_entry(dead_root, &fs_info->dead_roots,
					    root_list) {
				if (dead_root->root_key.objectid ==
				    found_key.objectid) {
					is_dead_root = 1;
					break;
				}
			}
			spin_unlock(&fs_info->trans_lock);
			if (is_dead_root) {
				/* prevent this orphan from being found again */
				key.offset = found_key.objectid - 1;
				continue;
			}
		}
3204
		/*
J
Josef Bacik 已提交
3205 3206
		 * Inode is already gone but the orphan item is still there,
		 * kill the orphan item.
3207
		 */
J
Josef Bacik 已提交
3208 3209
		if (ret == -ESTALE) {
			trans = btrfs_start_transaction(root, 1);
3210 3211 3212 3213
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				goto out;
			}
3214 3215
			btrfs_debug(root->fs_info, "auto deleting %Lu",
				found_key.objectid);
J
Josef Bacik 已提交
3216 3217
			ret = btrfs_del_orphan_item(trans, root,
						    found_key.objectid);
3218
			BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
3219
			btrfs_end_transaction(trans, root);
3220 3221 3222
			continue;
		}

J
Josef Bacik 已提交
3223 3224 3225 3226
		/*
		 * add this inode to the orphan list so btrfs_orphan_del does
		 * the proper thing when we hit it
		 */
3227 3228
		set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			&BTRFS_I(inode)->runtime_flags);
3229
		atomic_inc(&root->orphan_inodes);
J
Josef Bacik 已提交
3230

3231 3232
		/* if we have links, this was a truncate, lets do that */
		if (inode->i_nlink) {
3233 3234 3235 3236 3237
			if (!S_ISREG(inode->i_mode)) {
				WARN_ON(1);
				iput(inode);
				continue;
			}
3238
			nr_truncate++;
3239 3240 3241 3242

			/* 1 for the orphan item deletion. */
			trans = btrfs_start_transaction(root, 1);
			if (IS_ERR(trans)) {
3243
				iput(inode);
3244 3245 3246 3247 3248
				ret = PTR_ERR(trans);
				goto out;
			}
			ret = btrfs_orphan_add(trans, inode);
			btrfs_end_transaction(trans, root);
3249 3250
			if (ret) {
				iput(inode);
3251
				goto out;
3252
			}
3253

3254
			ret = btrfs_truncate(inode);
3255 3256
			if (ret)
				btrfs_orphan_del(NULL, inode);
3257 3258 3259 3260 3261 3262
		} else {
			nr_unlink++;
		}

		/* this will do delete_inode and everything for us */
		iput(inode);
3263 3264
		if (ret)
			goto out;
3265
	}
3266 3267 3268
	/* release the path since we're done with it */
	btrfs_release_path(path);

3269 3270 3271 3272 3273 3274 3275
	root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;

	if (root->orphan_block_rsv)
		btrfs_block_rsv_release(root, root->orphan_block_rsv,
					(u64)-1);

	if (root->orphan_block_rsv || root->orphan_item_inserted) {
3276
		trans = btrfs_join_transaction(root);
3277 3278
		if (!IS_ERR(trans))
			btrfs_end_transaction(trans, root);
3279
	}
3280 3281

	if (nr_unlink)
3282
		btrfs_debug(root->fs_info, "unlinked %d orphans", nr_unlink);
3283
	if (nr_truncate)
3284
		btrfs_debug(root->fs_info, "truncated %d orphans", nr_truncate);
3285 3286 3287

out:
	if (ret)
3288 3289
		btrfs_crit(root->fs_info,
			"could not do orphan cleanup %d", ret);
3290 3291
	btrfs_free_path(path);
	return ret;
3292 3293
}

3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
/*
 * very simple check to peek ahead in the leaf looking for xattrs.  If we
 * don't find any xattrs, we know there can't be any acls.
 *
 * slot is the slot the inode is in, objectid is the objectid of the inode
 */
static noinline int acls_after_inode_item(struct extent_buffer *leaf,
					  int slot, u64 objectid)
{
	u32 nritems = btrfs_header_nritems(leaf);
	struct btrfs_key found_key;
3305 3306
	static u64 xattr_access = 0;
	static u64 xattr_default = 0;
3307 3308
	int scanned = 0;

3309 3310 3311 3312 3313 3314 3315
	if (!xattr_access) {
		xattr_access = btrfs_name_hash(POSIX_ACL_XATTR_ACCESS,
					strlen(POSIX_ACL_XATTR_ACCESS));
		xattr_default = btrfs_name_hash(POSIX_ACL_XATTR_DEFAULT,
					strlen(POSIX_ACL_XATTR_DEFAULT));
	}

3316 3317 3318 3319 3320 3321 3322 3323 3324
	slot++;
	while (slot < nritems) {
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		/* we found a different objectid, there must not be acls */
		if (found_key.objectid != objectid)
			return 0;

		/* we found an xattr, assume we've got an acl */
3325 3326 3327 3328 3329
		if (found_key.type == BTRFS_XATTR_ITEM_KEY) {
			if (found_key.offset == xattr_access ||
			    found_key.offset == xattr_default)
				return 1;
		}
3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356

		/*
		 * we found a key greater than an xattr key, there can't
		 * be any acls later on
		 */
		if (found_key.type > BTRFS_XATTR_ITEM_KEY)
			return 0;

		slot++;
		scanned++;

		/*
		 * it goes inode, inode backrefs, xattrs, extents,
		 * so if there are a ton of hard links to an inode there can
		 * be a lot of backrefs.  Don't waste time searching too hard,
		 * this is just an optimization
		 */
		if (scanned >= 8)
			break;
	}
	/* we hit the end of the leaf before we found an xattr or
	 * something larger than an xattr.  We have to assume the inode
	 * has acls
	 */
	return 1;
}

C
Chris Mason 已提交
3357 3358 3359
/*
 * read an inode from the btree into the in-memory inode
 */
3360
static void btrfs_read_locked_inode(struct inode *inode)
C
Chris Mason 已提交
3361 3362
{
	struct btrfs_path *path;
3363
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3364
	struct btrfs_inode_item *inode_item;
3365
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
3366 3367
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
3368
	int maybe_acls;
J
Josef Bacik 已提交
3369
	u32 rdev;
C
Chris Mason 已提交
3370
	int ret;
3371 3372 3373 3374 3375
	bool filled = false;

	ret = btrfs_fill_inode(inode, &rdev);
	if (!ret)
		filled = true;
C
Chris Mason 已提交
3376 3377

	path = btrfs_alloc_path();
3378 3379 3380
	if (!path)
		goto make_bad;

3381
	path->leave_spinning = 1;
C
Chris Mason 已提交
3382
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
C
Chris Mason 已提交
3383

C
Chris Mason 已提交
3384
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
3385
	if (ret)
C
Chris Mason 已提交
3386 3387
		goto make_bad;

3388
	leaf = path->nodes[0];
3389 3390 3391 3392

	if (filled)
		goto cache_acl;

3393 3394 3395
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_inode_item);
	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
M
Miklos Szeredi 已提交
3396
	set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
3397 3398
	i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
	i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
3399
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412

	tspec = btrfs_inode_atime(inode_item);
	inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

	tspec = btrfs_inode_mtime(inode_item);
	inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

	tspec = btrfs_inode_ctime(inode_item);
	inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

3413
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
3414
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
J
Josef Bacik 已提交
3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
	BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);

	/*
	 * If we were modified in the current generation and evicted from memory
	 * and then re-read we need to do a full sync since we don't have any
	 * idea about which extents were modified before we were evicted from
	 * cache.
	 */
	if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
		set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
			&BTRFS_I(inode)->runtime_flags);

3427
	inode->i_version = btrfs_inode_sequence(leaf, inode_item);
3428
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
3429
	inode->i_rdev = 0;
3430 3431
	rdev = btrfs_inode_rdev(leaf, inode_item);

3432
	BTRFS_I(inode)->index_cnt = (u64)-1;
3433
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
3434
cache_acl:
3435 3436 3437 3438
	/*
	 * try to precache a NULL acl entry for files that don't have
	 * any xattrs or acls
	 */
L
Li Zefan 已提交
3439 3440
	maybe_acls = acls_after_inode_item(leaf, path->slots[0],
					   btrfs_ino(inode));
3441 3442
	if (!maybe_acls)
		cache_no_acl(inode);
3443

C
Chris Mason 已提交
3444 3445 3446 3447 3448
	btrfs_free_path(path);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
3449
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3450
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
		break;
	case S_IFDIR:
		inode->i_fop = &btrfs_dir_file_operations;
		if (root == root->fs_info->tree_root)
			inode->i_op = &btrfs_dir_ro_inode_operations;
		else
			inode->i_op = &btrfs_dir_inode_operations;
		break;
	case S_IFLNK:
		inode->i_op = &btrfs_symlink_inode_operations;
		inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
3464
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
3465
		break;
J
Josef Bacik 已提交
3466
	default:
J
Jim Owens 已提交
3467
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
3468 3469
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
3470
	}
3471 3472

	btrfs_update_iflags(inode);
C
Chris Mason 已提交
3473 3474 3475 3476 3477 3478 3479
	return;

make_bad:
	btrfs_free_path(path);
	make_bad_inode(inode);
}

C
Chris Mason 已提交
3480 3481 3482
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
3483 3484
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
3485
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
3486 3487
			    struct inode *inode)
{
3488 3489 3490
	struct btrfs_map_token token;

	btrfs_init_map_token(&token);
3491

3492 3493 3494 3495 3496 3497
	btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
	btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
	btrfs_set_token_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size,
				   &token);
	btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
	btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
3498

3499 3500 3501 3502
	btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item),
				     inode->i_atime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item),
				      inode->i_atime.tv_nsec, &token);
3503

3504 3505 3506 3507
	btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item),
				     inode->i_mtime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item),
				      inode->i_mtime.tv_nsec, &token);
3508

3509 3510 3511 3512
	btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item),
				     inode->i_ctime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item),
				      inode->i_ctime.tv_nsec, &token);
3513

3514 3515 3516 3517 3518 3519 3520 3521 3522
	btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
				     &token);
	btrfs_set_token_inode_generation(leaf, item, BTRFS_I(inode)->generation,
					 &token);
	btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
	btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
	btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
	btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
	btrfs_set_token_inode_block_group(leaf, item, 0, &token);
C
Chris Mason 已提交
3523 3524
}

C
Chris Mason 已提交
3525 3526 3527
/*
 * copy everything in the in-memory inode into the btree.
 */
3528
static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
3529
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
3530 3531 3532
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
3533
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3534 3535 3536
	int ret;

	path = btrfs_alloc_path();
3537 3538 3539
	if (!path)
		return -ENOMEM;

3540
	path->leave_spinning = 1;
3541 3542
	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
				 1);
C
Chris Mason 已提交
3543 3544 3545 3546 3547 3548
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

3549
	btrfs_unlock_up_safe(path, 1);
3550 3551
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
3552
				    struct btrfs_inode_item);
C
Chris Mason 已提交
3553

3554
	fill_inode_item(trans, leaf, inode_item, inode);
3555
	btrfs_mark_buffer_dirty(leaf);
3556
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
3557 3558 3559 3560 3561 3562
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}

3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
/*
 * copy everything in the in-memory inode into the btree.
 */
noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode)
{
	int ret;

	/*
	 * If the inode is a free space inode, we can deadlock during commit
	 * if we put it into the delayed code.
	 *
	 * The data relocation inode should also be directly updated
	 * without delay
	 */
3578
	if (!btrfs_is_free_space_inode(inode)
3579
	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
3580 3581
		btrfs_update_root_times(trans, root);

3582 3583 3584 3585 3586 3587 3588 3589 3590
		ret = btrfs_delayed_update_inode(trans, root, inode);
		if (!ret)
			btrfs_set_inode_last_trans(trans, inode);
		return ret;
	}

	return btrfs_update_inode_item(trans, root, inode);
}

3591 3592 3593
noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root,
					 struct inode *inode)
3594 3595 3596 3597 3598 3599 3600 3601 3602
{
	int ret;

	ret = btrfs_update_inode(trans, root, inode);
	if (ret == -ENOSPC)
		return btrfs_update_inode_item(trans, root, inode);
	return ret;
}

C
Chris Mason 已提交
3603 3604 3605 3606 3607
/*
 * unlink helper that gets used here in inode.c and in the tree logging
 * recovery code.  It remove a link in a directory with a given name, and
 * also drops the back refs in the inode to the directory
 */
3608 3609 3610 3611
static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct inode *dir, struct inode *inode,
				const char *name, int name_len)
C
Chris Mason 已提交
3612 3613 3614
{
	struct btrfs_path *path;
	int ret = 0;
3615
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3616
	struct btrfs_dir_item *di;
3617
	struct btrfs_key key;
3618
	u64 index;
L
Li Zefan 已提交
3619 3620
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
C
Chris Mason 已提交
3621 3622

	path = btrfs_alloc_path();
3623 3624
	if (!path) {
		ret = -ENOMEM;
3625
		goto out;
3626 3627
	}

3628
	path->leave_spinning = 1;
L
Li Zefan 已提交
3629
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
C
Chris Mason 已提交
3630 3631 3632 3633 3634 3635 3636 3637 3638
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
3639 3640
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
3641
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
3642 3643
	if (ret)
		goto err;
3644
	btrfs_release_path(path);
C
Chris Mason 已提交
3645

L
Li Zefan 已提交
3646 3647
	ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
				  dir_ino, &index);
3648
	if (ret) {
3649 3650 3651 3652
		btrfs_info(root->fs_info,
			"failed to delete reference to %.*s, inode %llu parent %llu",
			name_len, name,
			(unsigned long long)ino, (unsigned long long)dir_ino);
3653
		btrfs_abort_transaction(trans, root, ret);
3654 3655 3656
		goto err;
	}

3657
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3658 3659
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
3660
		goto err;
3661
	}
C
Chris Mason 已提交
3662

3663
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
L
Li Zefan 已提交
3664
					 inode, dir_ino);
3665 3666 3667 3668
	if (ret != 0 && ret != -ENOENT) {
		btrfs_abort_transaction(trans, root, ret);
		goto err;
	}
3669 3670 3671

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
3672 3673
	if (ret == -ENOENT)
		ret = 0;
3674 3675
	else if (ret)
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
3676 3677
err:
	btrfs_free_path(path);
3678 3679 3680 3681
	if (ret)
		goto out;

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3682 3683
	inode_inc_iversion(inode);
	inode_inc_iversion(dir);
3684
	inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3685
	ret = btrfs_update_inode(trans, root, dir);
3686
out:
C
Chris Mason 已提交
3687 3688 3689
	return ret;
}

3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root,
		       struct inode *dir, struct inode *inode,
		       const char *name, int name_len)
{
	int ret;
	ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
	if (!ret) {
		btrfs_drop_nlink(inode);
		ret = btrfs_update_inode(trans, root, inode);
	}
	return ret;
}
C
Chris Mason 已提交
3703

3704 3705 3706
/*
 * helper to start transaction for unlink and rmdir.
 *
3707 3708 3709 3710
 * unlink and rmdir are special in btrfs, they do not always free space, so
 * if we cannot make our reservations the normal way try and see if there is
 * plenty of slack room in the global reserve to migrate, otherwise we cannot
 * allow the unlink to occur.
3711
 */
3712
static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir)
3713
{
C
Chris Mason 已提交
3714
	struct btrfs_trans_handle *trans;
3715
	struct btrfs_root *root = BTRFS_I(dir)->root;
3716 3717
	int ret;

3718 3719 3720 3721 3722 3723 3724
	/*
	 * 1 for the possible orphan item
	 * 1 for the dir item
	 * 1 for the dir index
	 * 1 for the inode ref
	 * 1 for the inode
	 */
3725
	trans = btrfs_start_transaction(root, 5);
3726 3727
	if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
		return trans;
3728

3729 3730
	if (PTR_ERR(trans) == -ENOSPC) {
		u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
3731

3732 3733 3734 3735 3736 3737 3738 3739 3740
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return trans;
		ret = btrfs_cond_migrate_bytes(root->fs_info,
					       &root->fs_info->trans_block_rsv,
					       num_bytes, 5);
		if (ret) {
			btrfs_end_transaction(trans, root);
			return ERR_PTR(ret);
3741
		}
3742
		trans->block_rsv = &root->fs_info->trans_block_rsv;
3743
		trans->bytes_reserved = num_bytes;
3744
	}
3745
	return trans;
3746 3747 3748 3749 3750 3751 3752 3753 3754
}

static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
	struct inode *inode = dentry->d_inode;
	int ret;

3755
	trans = __unlink_start_trans(dir);
3756 3757
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3758

3759 3760
	btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);

3761 3762
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
3763 3764
	if (ret)
		goto out;
3765

3766
	if (inode->i_nlink == 0) {
3767
		ret = btrfs_orphan_add(trans, inode);
3768 3769
		if (ret)
			goto out;
3770
	}
3771

3772
out:
3773
	btrfs_end_transaction(trans, root);
3774
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
3775 3776 3777
	return ret;
}

3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788
int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
			struct btrfs_root *root,
			struct inode *dir, u64 objectid,
			const char *name, int name_len)
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
	u64 index;
	int ret;
L
Li Zefan 已提交
3789
	u64 dir_ino = btrfs_ino(dir);
3790 3791 3792 3793 3794

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

L
Li Zefan 已提交
3795
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3796
				   name, name_len, -1);
3797 3798 3799 3800 3801 3802 3803
	if (IS_ERR_OR_NULL(di)) {
		if (!di)
			ret = -ENOENT;
		else
			ret = PTR_ERR(di);
		goto out;
	}
3804 3805 3806 3807 3808

	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
	WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
3809 3810 3811 3812
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3813
	btrfs_release_path(path);
3814 3815 3816

	ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
				 objectid, root->root_key.objectid,
L
Li Zefan 已提交
3817
				 dir_ino, &index, name, name_len);
3818
	if (ret < 0) {
3819 3820 3821 3822
		if (ret != -ENOENT) {
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
L
Li Zefan 已提交
3823
		di = btrfs_search_dir_index_item(root, path, dir_ino,
3824
						 name, name_len);
3825 3826 3827 3828 3829 3830 3831 3832
		if (IS_ERR_OR_NULL(di)) {
			if (!di)
				ret = -ENOENT;
			else
				ret = PTR_ERR(di);
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
3833 3834 3835

		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3836
		btrfs_release_path(path);
3837 3838
		index = key.offset;
	}
3839
	btrfs_release_path(path);
3840

3841
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3842 3843 3844 3845
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3846 3847

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3848
	inode_inc_iversion(dir);
3849
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3850
	ret = btrfs_update_inode_fallback(trans, root, dir);
3851 3852 3853
	if (ret)
		btrfs_abort_transaction(trans, root, ret);
out:
3854
	btrfs_free_path(path);
3855
	return ret;
3856 3857
}

C
Chris Mason 已提交
3858 3859 3860
static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
3861
	int err = 0;
C
Chris Mason 已提交
3862 3863 3864
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;

3865
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
Y
Yan 已提交
3866
		return -ENOTEMPTY;
3867 3868
	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
		return -EPERM;
Y
Yan 已提交
3869

3870
	trans = __unlink_start_trans(dir);
3871
	if (IS_ERR(trans))
3872 3873
		return PTR_ERR(trans);

L
Li Zefan 已提交
3874
	if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
3875 3876 3877 3878 3879 3880 3881
		err = btrfs_unlink_subvol(trans, root, dir,
					  BTRFS_I(inode)->location.objectid,
					  dentry->d_name.name,
					  dentry->d_name.len);
		goto out;
	}

3882 3883
	err = btrfs_orphan_add(trans, inode);
	if (err)
3884
		goto out;
3885

C
Chris Mason 已提交
3886
	/* now the directory is empty */
3887 3888
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
C
Chris Mason 已提交
3889
	if (!err)
3890
		btrfs_i_size_write(inode, 0);
3891
out:
3892
	btrfs_end_transaction(trans, root);
3893
	btrfs_btree_balance_dirty(root);
3894

C
Chris Mason 已提交
3895 3896 3897 3898 3899 3900
	return err;
}

/*
 * this can truncate away extent items, csum items and directory items.
 * It starts at a high offset and removes keys until it can't find
C
Chris Mason 已提交
3901
 * any higher than new_size
C
Chris Mason 已提交
3902 3903 3904
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
3905 3906 3907
 *
 * min_type is the minimum key type to truncate down to.  If set to 0, this
 * will kill all the items on this inode, including the INODE_ITEM_KEY.
C
Chris Mason 已提交
3908
 */
3909 3910 3911 3912
int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
			       struct inode *inode,
			       u64 new_size, u32 min_type)
C
Chris Mason 已提交
3913 3914
{
	struct btrfs_path *path;
3915
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3916
	struct btrfs_file_extent_item *fi;
3917 3918
	struct btrfs_key key;
	struct btrfs_key found_key;
C
Chris Mason 已提交
3919
	u64 extent_start = 0;
3920
	u64 extent_num_bytes = 0;
3921
	u64 extent_offset = 0;
C
Chris Mason 已提交
3922
	u64 item_end = 0;
3923
	u32 found_type = (u8)-1;
C
Chris Mason 已提交
3924 3925
	int found_extent;
	int del_item;
3926 3927
	int pending_del_nr = 0;
	int pending_del_slot = 0;
3928
	int extent_type = -1;
3929 3930
	int ret;
	int err = 0;
L
Li Zefan 已提交
3931
	u64 ino = btrfs_ino(inode);
3932 3933

	BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
C
Chris Mason 已提交
3934

3935 3936 3937 3938 3939
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->reada = -1;

J
Josef Bacik 已提交
3940 3941 3942 3943 3944
	/*
	 * We want to drop from the next block forward in case this new size is
	 * not block aligned since we will be keeping the last block of the
	 * extent just the way it is.
	 */
3945
	if (root->ref_cows || root == root->fs_info->tree_root)
3946 3947
		btrfs_drop_extent_cache(inode, ALIGN(new_size,
					root->sectorsize), (u64)-1, 0);
3948

3949 3950 3951 3952 3953 3954 3955 3956 3957
	/*
	 * This function is also used to drop the items in the log tree before
	 * we relog the inode, so if root != BTRFS_I(inode)->root, it means
	 * it is used to drop the loged items. So we shouldn't kill the delayed
	 * items.
	 */
	if (min_type == 0 && root == BTRFS_I(inode)->root)
		btrfs_kill_delayed_inode_items(inode);

L
Li Zefan 已提交
3958
	key.objectid = ino;
C
Chris Mason 已提交
3959
	key.offset = (u64)-1;
3960 3961
	key.type = (u8)-1;

3962
search_again:
3963
	path->leave_spinning = 1;
3964
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3965 3966 3967 3968
	if (ret < 0) {
		err = ret;
		goto out;
	}
C
Chris Mason 已提交
3969

3970
	if (ret > 0) {
3971 3972 3973
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
3974 3975
		if (path->slots[0] == 0)
			goto out;
3976 3977 3978
		path->slots[0]--;
	}

C
Chris Mason 已提交
3979
	while (1) {
C
Chris Mason 已提交
3980
		fi = NULL;
3981 3982 3983
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		found_type = btrfs_key_type(&found_key);
C
Chris Mason 已提交
3984

L
Li Zefan 已提交
3985
		if (found_key.objectid != ino)
C
Chris Mason 已提交
3986
			break;
3987

3988
		if (found_type < min_type)
C
Chris Mason 已提交
3989 3990
			break;

3991
		item_end = found_key.offset;
C
Chris Mason 已提交
3992
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
3993
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
3994
					    struct btrfs_file_extent_item);
3995 3996
			extent_type = btrfs_file_extent_type(leaf, fi);
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3997
				item_end +=
3998
				    btrfs_file_extent_num_bytes(leaf, fi);
3999 4000
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
C
Chris Mason 已提交
4001
									 fi);
C
Chris Mason 已提交
4002
			}
4003
			item_end--;
C
Chris Mason 已提交
4004
		}
4005 4006 4007 4008
		if (found_type > min_type) {
			del_item = 1;
		} else {
			if (item_end < new_size)
4009
				break;
4010 4011 4012 4013
			if (found_key.offset >= new_size)
				del_item = 1;
			else
				del_item = 0;
C
Chris Mason 已提交
4014 4015 4016
		}
		found_extent = 0;
		/* FIXME, shrink the extent if the ref count is only 1 */
4017 4018 4019 4020
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
4021
			u64 num_dec;
4022
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
4023
			if (!del_item) {
4024 4025
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
4026 4027 4028
				extent_num_bytes = ALIGN(new_size -
						found_key.offset,
						root->sectorsize);
4029 4030 4031
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
C
Chris Mason 已提交
4032
					   extent_num_bytes);
4033
				if (root->ref_cows && extent_start != 0)
4034
					inode_sub_bytes(inode, num_dec);
4035
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
4036
			} else {
4037 4038 4039
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
4040 4041 4042
				extent_offset = found_key.offset -
					btrfs_file_extent_offset(leaf, fi);

C
Chris Mason 已提交
4043
				/* FIXME blocksize != 4096 */
C
Chris Mason 已提交
4044
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
4045 4046
				if (extent_start != 0) {
					found_extent = 1;
4047
					if (root->ref_cows)
4048
						inode_sub_bytes(inode, num_dec);
4049
				}
C
Chris Mason 已提交
4050
			}
C
Chris Mason 已提交
4051
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
4052 4053 4054 4055 4056 4057 4058 4059
			/*
			 * we can't truncate inline items that have had
			 * special encodings
			 */
			if (!del_item &&
			    btrfs_file_extent_compression(leaf, fi) == 0 &&
			    btrfs_file_extent_encryption(leaf, fi) == 0 &&
			    btrfs_file_extent_other_encoding(leaf, fi) == 0) {
4060 4061 4062
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
4063 4064
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
4065 4066 4067
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
4068
				btrfs_truncate_item(root, path, size, 1);
4069
			} else if (root->ref_cows) {
4070 4071
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
C
Chris Mason 已提交
4072
			}
C
Chris Mason 已提交
4073
		}
4074
delete:
C
Chris Mason 已提交
4075
		if (del_item) {
4076 4077 4078 4079 4080 4081 4082 4083 4084 4085
			if (!pending_del_nr) {
				/* no pending yet, add ourselves */
				pending_del_slot = path->slots[0];
				pending_del_nr = 1;
			} else if (pending_del_nr &&
				   path->slots[0] + 1 == pending_del_slot) {
				/* hop on the pending chunk */
				pending_del_nr++;
				pending_del_slot = path->slots[0];
			} else {
C
Chris Mason 已提交
4086
				BUG();
4087
			}
C
Chris Mason 已提交
4088 4089 4090
		} else {
			break;
		}
4091 4092
		if (found_extent && (root->ref_cows ||
				     root == root->fs_info->tree_root)) {
4093
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
4094
			ret = btrfs_free_extent(trans, root, extent_start,
4095 4096
						extent_num_bytes, 0,
						btrfs_header_owner(leaf),
A
Arne Jansen 已提交
4097
						ino, extent_offset, 0);
C
Chris Mason 已提交
4098 4099
			BUG_ON(ret);
		}
4100

4101 4102 4103 4104 4105 4106 4107 4108 4109
		if (found_type == BTRFS_INODE_ITEM_KEY)
			break;

		if (path->slots[0] == 0 ||
		    path->slots[0] != pending_del_slot) {
			if (pending_del_nr) {
				ret = btrfs_del_items(trans, root, path,
						pending_del_slot,
						pending_del_nr);
4110 4111 4112 4113 4114
				if (ret) {
					btrfs_abort_transaction(trans,
								root, ret);
					goto error;
				}
4115 4116
				pending_del_nr = 0;
			}
4117
			btrfs_release_path(path);
4118
			goto search_again;
4119 4120
		} else {
			path->slots[0]--;
4121
		}
C
Chris Mason 已提交
4122
	}
4123
out:
4124 4125 4126
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
4127 4128
		if (ret)
			btrfs_abort_transaction(trans, root, ret);
4129
	}
4130
error:
C
Chris Mason 已提交
4131
	btrfs_free_path(path);
4132
	return err;
C
Chris Mason 已提交
4133 4134 4135
}

/*
J
Josef Bacik 已提交
4136 4137 4138 4139 4140 4141 4142 4143 4144
 * btrfs_truncate_page - read, zero a chunk and write a page
 * @inode - inode that we're zeroing
 * @from - the offset to start zeroing
 * @len - the length to zero, 0 to zero the entire range respective to the
 *	offset
 * @front - zero up to the offset instead of from the offset on
 *
 * This will find the page for the "from" offset and cow the page and zero the
 * part we want to zero.  This is used with truncate and hole punching.
C
Chris Mason 已提交
4145
 */
J
Josef Bacik 已提交
4146 4147
int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
			int front)
C
Chris Mason 已提交
4148
{
J
Josef Bacik 已提交
4149
	struct address_space *mapping = inode->i_mapping;
4150
	struct btrfs_root *root = BTRFS_I(inode)->root;
4151 4152
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
4153
	struct extent_state *cached_state = NULL;
4154
	char *kaddr;
4155
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
4156 4157 4158
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
4159
	gfp_t mask = btrfs_alloc_write_mask(mapping);
C
Chris Mason 已提交
4160
	int ret = 0;
4161
	u64 page_start;
4162
	u64 page_end;
C
Chris Mason 已提交
4163

J
Josef Bacik 已提交
4164 4165
	if ((offset & (blocksize - 1)) == 0 &&
	    (!len || ((len & (blocksize - 1)) == 0)))
C
Chris Mason 已提交
4166
		goto out;
4167
	ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
4168 4169
	if (ret)
		goto out;
C
Chris Mason 已提交
4170

4171
again:
4172
	page = find_or_create_page(mapping, index, mask);
4173
	if (!page) {
4174
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
4175
		ret = -ENOMEM;
C
Chris Mason 已提交
4176
		goto out;
4177
	}
4178 4179 4180 4181

	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;

C
Chris Mason 已提交
4182
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
4183
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
4184
		lock_page(page);
4185 4186 4187 4188 4189
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
4190 4191
		if (!PageUptodate(page)) {
			ret = -EIO;
4192
			goto out_unlock;
C
Chris Mason 已提交
4193 4194
		}
	}
4195
	wait_on_page_writeback(page);
4196

4197
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
4198 4199 4200 4201
	set_page_extent_mapped(page);

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
4202 4203
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
4204 4205
		unlock_page(page);
		page_cache_release(page);
4206
		btrfs_start_ordered_extent(inode, ordered, 1);
4207 4208 4209 4210
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

4211
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
4212 4213
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
4214
			  0, 0, &cached_state, GFP_NOFS);
4215

4216 4217
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
J
Josef Bacik 已提交
4218
	if (ret) {
4219 4220
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
4221 4222 4223
		goto out_unlock;
	}

4224
	if (offset != PAGE_CACHE_SIZE) {
J
Josef Bacik 已提交
4225 4226
		if (!len)
			len = PAGE_CACHE_SIZE - offset;
4227
		kaddr = kmap(page);
J
Josef Bacik 已提交
4228 4229 4230 4231
		if (front)
			memset(kaddr, 0, offset);
		else
			memset(kaddr + offset, 0, len);
4232 4233 4234
		flush_dcache_page(page);
		kunmap(page);
	}
4235
	ClearPageChecked(page);
4236
	set_page_dirty(page);
4237 4238
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
			     GFP_NOFS);
C
Chris Mason 已提交
4239

4240
out_unlock:
4241
	if (ret)
4242
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
4243 4244 4245 4246 4247 4248
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

4249 4250 4251 4252 4253 4254
/*
 * This function puts in dummy file extents for the area we're creating a hole
 * for.  So if we are truncating this file to a larger size we need to insert
 * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
 * the range between oldsize and size
 */
4255
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
C
Chris Mason 已提交
4256
{
Y
Yan Zheng 已提交
4257 4258 4259
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4260
	struct extent_map *em = NULL;
4261
	struct extent_state *cached_state = NULL;
J
Josef Bacik 已提交
4262
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4263 4264
	u64 hole_start = ALIGN(oldsize, root->sectorsize);
	u64 block_end = ALIGN(size, root->sectorsize);
Y
Yan Zheng 已提交
4265 4266 4267
	u64 last_byte;
	u64 cur_offset;
	u64 hole_size;
J
Josef Bacik 已提交
4268
	int err = 0;
C
Chris Mason 已提交
4269

4270 4271 4272 4273 4274 4275 4276 4277 4278
	/*
	 * If our size started in the middle of a page we need to zero out the
	 * rest of the page before we expand the i_size, otherwise we could
	 * expose stale data.
	 */
	err = btrfs_truncate_page(inode, oldsize, 0, 0);
	if (err)
		return err;

Y
Yan Zheng 已提交
4279 4280 4281 4282 4283 4284 4285
	if (size <= hole_start)
		return 0;

	while (1) {
		struct btrfs_ordered_extent *ordered;
		btrfs_wait_ordered_range(inode, hole_start,
					 block_end - hole_start);
4286
		lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
4287
				 &cached_state);
Y
Yan Zheng 已提交
4288 4289 4290
		ordered = btrfs_lookup_ordered_extent(inode, hole_start);
		if (!ordered)
			break;
4291 4292
		unlock_extent_cached(io_tree, hole_start, block_end - 1,
				     &cached_state, GFP_NOFS);
Y
Yan Zheng 已提交
4293 4294
		btrfs_put_ordered_extent(ordered);
	}
C
Chris Mason 已提交
4295

Y
Yan Zheng 已提交
4296 4297 4298 4299
	cur_offset = hole_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				block_end - cur_offset, 0);
4300 4301
		if (IS_ERR(em)) {
			err = PTR_ERR(em);
4302
			em = NULL;
4303 4304
			break;
		}
Y
Yan Zheng 已提交
4305
		last_byte = min(extent_map_end(em), block_end);
4306
		last_byte = ALIGN(last_byte , root->sectorsize);
4307
		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
J
Josef Bacik 已提交
4308
			struct extent_map *hole_em;
Y
Yan Zheng 已提交
4309
			hole_size = last_byte - cur_offset;
J
Josef Bacik 已提交
4310

4311
			trans = btrfs_start_transaction(root, 3);
4312 4313
			if (IS_ERR(trans)) {
				err = PTR_ERR(trans);
J
Josef Bacik 已提交
4314
				break;
4315
			}
4316

J
Josef Bacik 已提交
4317 4318
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
4319
						 cur_offset + hole_size, 1);
4320
			if (err) {
4321
				btrfs_abort_transaction(trans, root, err);
4322
				btrfs_end_transaction(trans, root);
4323
				break;
4324
			}
4325

Y
Yan Zheng 已提交
4326
			err = btrfs_insert_file_extent(trans, root,
L
Li Zefan 已提交
4327
					btrfs_ino(inode), cur_offset, 0,
Y
Yan Zheng 已提交
4328 4329
					0, hole_size, 0, hole_size,
					0, 0, 0);
4330
			if (err) {
4331
				btrfs_abort_transaction(trans, root, err);
4332
				btrfs_end_transaction(trans, root);
4333
				break;
4334
			}
4335

J
Josef Bacik 已提交
4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346
			btrfs_drop_extent_cache(inode, cur_offset,
						cur_offset + hole_size - 1, 0);
			hole_em = alloc_extent_map();
			if (!hole_em) {
				set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
					&BTRFS_I(inode)->runtime_flags);
				goto next;
			}
			hole_em->start = cur_offset;
			hole_em->len = hole_size;
			hole_em->orig_start = cur_offset;
4347

J
Josef Bacik 已提交
4348 4349
			hole_em->block_start = EXTENT_MAP_HOLE;
			hole_em->block_len = 0;
4350
			hole_em->orig_block_len = 0;
J
Josef Bacik 已提交
4351
			hole_em->ram_bytes = hole_size;
J
Josef Bacik 已提交
4352 4353 4354
			hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
			hole_em->compress_type = BTRFS_COMPRESS_NONE;
			hole_em->generation = trans->transid;
4355

J
Josef Bacik 已提交
4356 4357
			while (1) {
				write_lock(&em_tree->lock);
J
Josef Bacik 已提交
4358
				err = add_extent_mapping(em_tree, hole_em, 1);
J
Josef Bacik 已提交
4359 4360 4361 4362 4363 4364 4365 4366 4367
				write_unlock(&em_tree->lock);
				if (err != -EEXIST)
					break;
				btrfs_drop_extent_cache(inode, cur_offset,
							cur_offset +
							hole_size - 1, 0);
			}
			free_extent_map(hole_em);
next:
4368
			btrfs_update_inode(trans, root, inode);
4369
			btrfs_end_transaction(trans, root);
Y
Yan Zheng 已提交
4370 4371
		}
		free_extent_map(em);
4372
		em = NULL;
Y
Yan Zheng 已提交
4373
		cur_offset = last_byte;
4374
		if (cur_offset >= block_end)
Y
Yan Zheng 已提交
4375 4376
			break;
	}
4377

4378
	free_extent_map(em);
4379 4380
	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
			     GFP_NOFS);
Y
Yan Zheng 已提交
4381 4382
	return err;
}
C
Chris Mason 已提交
4383

4384
static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4385
{
4386 4387
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
4388
	loff_t oldsize = i_size_read(inode);
4389 4390
	loff_t newsize = attr->ia_size;
	int mask = attr->ia_valid;
4391 4392
	int ret;

4393
	if (newsize == oldsize)
4394 4395
		return 0;

4396 4397 4398 4399 4400 4401 4402 4403 4404
	/*
	 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
	 * special case where we need to update the times despite not having
	 * these flags set.  For all other operations the VFS set these flags
	 * explicitly if it wants a timestamp update.
	 */
	if (newsize != oldsize && (!(mask & (ATTR_CTIME | ATTR_MTIME))))
		inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);

4405 4406 4407
	if (newsize > oldsize) {
		truncate_pagecache(inode, oldsize, newsize);
		ret = btrfs_cont_expand(inode, oldsize, newsize);
4408
		if (ret)
4409 4410
			return ret;

4411 4412 4413 4414 4415 4416 4417
		trans = btrfs_start_transaction(root, 1);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

		i_size_write(inode, newsize);
		btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
		ret = btrfs_update_inode(trans, root, inode);
4418
		btrfs_end_transaction(trans, root);
4419
	} else {
4420

4421 4422 4423 4424 4425 4426
		/*
		 * We're truncating a file that used to have good data down to
		 * zero. Make sure it gets into the ordered flush list so that
		 * any new writes get down to disk quickly.
		 */
		if (newsize == 0)
4427 4428
			set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
				&BTRFS_I(inode)->runtime_flags);
4429

4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452
		/*
		 * 1 for the orphan item we're going to add
		 * 1 for the orphan item deletion.
		 */
		trans = btrfs_start_transaction(root, 2);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

		/*
		 * We need to do this in case we fail at _any_ point during the
		 * actual truncate.  Once we do the truncate_setsize we could
		 * invalidate pages which forces any outstanding ordered io to
		 * be instantly completed which will give us extents that need
		 * to be truncated.  If we fail to get an orphan inode down we
		 * could have left over extents that were never meant to live,
		 * so we need to garuntee from this point on that everything
		 * will be consistent.
		 */
		ret = btrfs_orphan_add(trans, inode);
		btrfs_end_transaction(trans, root);
		if (ret)
			return ret;

4453 4454
		/* we don't support swapfiles, so vmtruncate shouldn't fail */
		truncate_setsize(inode, newsize);
4455 4456 4457 4458 4459 4460

		/* Disable nonlocked read DIO to avoid the end less truncate */
		btrfs_inode_block_unlocked_dio(inode);
		inode_dio_wait(inode);
		btrfs_inode_resume_unlocked_dio(inode);

4461
		ret = btrfs_truncate(inode);
4462 4463
		if (ret && inode->i_nlink)
			btrfs_orphan_del(NULL, inode);
4464 4465
	}

4466
	return ret;
4467 4468
}

Y
Yan Zheng 已提交
4469 4470 4471
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
L
Li Zefan 已提交
4472
	struct btrfs_root *root = BTRFS_I(inode)->root;
Y
Yan Zheng 已提交
4473
	int err;
C
Chris Mason 已提交
4474

L
Li Zefan 已提交
4475 4476 4477
	if (btrfs_root_readonly(root))
		return -EROFS;

Y
Yan Zheng 已提交
4478 4479 4480
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
4481

4482
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
4483
		err = btrfs_setsize(inode, attr);
4484 4485
		if (err)
			return err;
C
Chris Mason 已提交
4486
	}
Y
Yan Zheng 已提交
4487

C
Christoph Hellwig 已提交
4488 4489
	if (attr->ia_valid) {
		setattr_copy(inode, attr);
4490
		inode_inc_iversion(inode);
4491
		err = btrfs_dirty_inode(inode);
C
Christoph Hellwig 已提交
4492

4493
		if (!err && attr->ia_valid & ATTR_MODE)
C
Christoph Hellwig 已提交
4494 4495
			err = btrfs_acl_chmod(inode);
	}
J
Josef Bacik 已提交
4496

C
Chris Mason 已提交
4497 4498
	return err;
}
4499

A
Al Viro 已提交
4500
void btrfs_evict_inode(struct inode *inode)
C
Chris Mason 已提交
4501 4502 4503
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
4504
	struct btrfs_block_rsv *rsv, *global_rsv;
4505
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
4506 4507
	int ret;

4508 4509
	trace_btrfs_inode_evict(inode);

C
Chris Mason 已提交
4510
	truncate_inode_pages(&inode->i_data, 0);
4511
	if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
4512
			       btrfs_is_free_space_inode(inode)))
A
Al Viro 已提交
4513 4514
		goto no_delete;

C
Chris Mason 已提交
4515
	if (is_bad_inode(inode)) {
4516
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
4517 4518
		goto no_delete;
	}
A
Al Viro 已提交
4519
	/* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
C
Chris Mason 已提交
4520
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
4521

4522
	if (root->fs_info->log_root_recovering) {
4523
		BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
4524
				 &BTRFS_I(inode)->runtime_flags));
4525 4526 4527
		goto no_delete;
	}

4528 4529 4530 4531 4532
	if (inode->i_nlink > 0) {
		BUG_ON(btrfs_root_refs(&root->root_item) != 0);
		goto no_delete;
	}

4533 4534 4535 4536 4537 4538
	ret = btrfs_commit_inode_delayed_inode(inode);
	if (ret) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}

4539
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
4540 4541 4542 4543
	if (!rsv) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}
J
Josef Bacik 已提交
4544
	rsv->size = min_size;
4545
	rsv->failfast = 1;
4546
	global_rsv = &root->fs_info->global_block_rsv;
4547

4548
	btrfs_i_size_write(inode, 0);
4549

4550
	/*
4551 4552 4553 4554
	 * This is a bit simpler than btrfs_truncate since we've already
	 * reserved our space for our orphan item in the unlink, so we just
	 * need to reserve some slack space in case we add bytes and update
	 * inode item when doing the truncate.
4555
	 */
4556
	while (1) {
M
Miao Xie 已提交
4557 4558
		ret = btrfs_block_rsv_refill(root, rsv, min_size,
					     BTRFS_RESERVE_FLUSH_LIMIT);
4559 4560 4561 4562 4563 4564 4565 4566

		/*
		 * Try and steal from the global reserve since we will
		 * likely not use this space anyway, we want to try as
		 * hard as possible to get this to work.
		 */
		if (ret)
			ret = btrfs_block_rsv_migrate(global_rsv, rsv, min_size);
4567 4568

		if (ret) {
4569 4570 4571
			btrfs_warn(root->fs_info,
				"Could not get space for a delete, will truncate on mount %d",
				ret);
4572 4573 4574
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
4575
		}
4576

4577
		trans = btrfs_join_transaction(root);
4578 4579 4580 4581
		if (IS_ERR(trans)) {
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
4582
		}
4583

4584 4585
		trans->block_rsv = rsv;

4586
		ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
4587
		if (ret != -ENOSPC)
4588
			break;
4589

4590
		trans->block_rsv = &root->fs_info->trans_block_rsv;
4591 4592
		btrfs_end_transaction(trans, root);
		trans = NULL;
4593
		btrfs_btree_balance_dirty(root);
4594
	}
4595

4596 4597
	btrfs_free_block_rsv(root, rsv);

4598
	if (ret == 0) {
4599
		trans->block_rsv = root->orphan_block_rsv;
4600 4601 4602
		ret = btrfs_orphan_del(trans, inode);
		BUG_ON(ret);
	}
4603

4604
	trans->block_rsv = &root->fs_info->trans_block_rsv;
4605 4606
	if (!(root == root->fs_info->tree_root ||
	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
L
Li Zefan 已提交
4607
		btrfs_return_ino(root, btrfs_ino(inode));
4608

4609
	btrfs_end_transaction(trans, root);
4610
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
4611
no_delete:
4612
	btrfs_remove_delayed_node(inode);
4613
	clear_inode(inode);
4614
	return;
C
Chris Mason 已提交
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628
}

/*
 * this returns the key found in the dir entry in the location pointer.
 * If no dir entries were found, location->objectid is 0.
 */
static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
			       struct btrfs_key *location)
{
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_root *root = BTRFS_I(dir)->root;
Y
Yan 已提交
4629
	int ret = 0;
C
Chris Mason 已提交
4630 4631

	path = btrfs_alloc_path();
4632 4633
	if (!path)
		return -ENOMEM;
4634

L
Li Zefan 已提交
4635
	di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
C
Chris Mason 已提交
4636
				    namelen, 0);
Y
Yan 已提交
4637 4638
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
4639

4640
	if (IS_ERR_OR_NULL(di))
4641
		goto out_err;
C
Chris Mason 已提交
4642

4643
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
4644 4645 4646
out:
	btrfs_free_path(path);
	return ret;
4647 4648 4649
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
4650 4651 4652 4653 4654 4655 4656 4657
}

/*
 * when we hit a tree root in a directory, the btrfs part of the inode
 * needs to be changed to reflect the root directory of the tree root.  This
 * is kind of like crossing a mount point.
 */
static int fixup_tree_root_location(struct btrfs_root *root,
4658 4659 4660 4661
				    struct inode *dir,
				    struct dentry *dentry,
				    struct btrfs_key *location,
				    struct btrfs_root **sub_root)
C
Chris Mason 已提交
4662
{
4663 4664 4665 4666 4667 4668
	struct btrfs_path *path;
	struct btrfs_root *new_root;
	struct btrfs_root_ref *ref;
	struct extent_buffer *leaf;
	int ret;
	int err = 0;
C
Chris Mason 已提交
4669

4670 4671 4672 4673 4674
	path = btrfs_alloc_path();
	if (!path) {
		err = -ENOMEM;
		goto out;
	}
C
Chris Mason 已提交
4675

4676 4677 4678 4679 4680 4681 4682 4683 4684
	err = -ENOENT;
	ret = btrfs_find_root_ref(root->fs_info->tree_root, path,
				  BTRFS_I(dir)->root->root_key.objectid,
				  location->objectid);
	if (ret) {
		if (ret < 0)
			err = ret;
		goto out;
	}
C
Chris Mason 已提交
4685

4686 4687
	leaf = path->nodes[0];
	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
L
Li Zefan 已提交
4688
	if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
4689 4690
	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
		goto out;
C
Chris Mason 已提交
4691

4692 4693 4694 4695 4696 4697
	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
				   (unsigned long)(ref + 1),
				   dentry->d_name.len);
	if (ret)
		goto out;

4698
	btrfs_release_path(path);
4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713

	new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
	if (IS_ERR(new_root)) {
		err = PTR_ERR(new_root);
		goto out;
	}

	*sub_root = new_root;
	location->objectid = btrfs_root_dirid(&new_root->root_item);
	location->type = BTRFS_INODE_ITEM_KEY;
	location->offset = 0;
	err = 0;
out:
	btrfs_free_path(path);
	return err;
C
Chris Mason 已提交
4714 4715
}

4716 4717 4718 4719
static void inode_tree_add(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_inode *entry;
4720 4721
	struct rb_node **p;
	struct rb_node *parent;
L
Li Zefan 已提交
4722
	u64 ino = btrfs_ino(inode);
4723

A
Al Viro 已提交
4724
	if (inode_unhashed(inode))
4725
		return;
4726 4727
again:
	parent = NULL;
4728
	spin_lock(&root->inode_lock);
4729
	p = &root->inode_tree.rb_node;
4730 4731 4732 4733
	while (*p) {
		parent = *p;
		entry = rb_entry(parent, struct btrfs_inode, rb_node);

L
Li Zefan 已提交
4734
		if (ino < btrfs_ino(&entry->vfs_inode))
4735
			p = &parent->rb_left;
L
Li Zefan 已提交
4736
		else if (ino > btrfs_ino(&entry->vfs_inode))
4737
			p = &parent->rb_right;
4738 4739
		else {
			WARN_ON(!(entry->vfs_inode.i_state &
A
Al Viro 已提交
4740
				  (I_WILL_FREE | I_FREEING)));
4741 4742 4743 4744
			rb_erase(parent, &root->inode_tree);
			RB_CLEAR_NODE(parent);
			spin_unlock(&root->inode_lock);
			goto again;
4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
		}
	}
	rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
	rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
	spin_unlock(&root->inode_lock);
}

static void inode_tree_del(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
4755
	int empty = 0;
4756

4757
	spin_lock(&root->inode_lock);
4758 4759 4760
	if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
		rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
		RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
4761
		empty = RB_EMPTY_ROOT(&root->inode_tree);
4762
	}
4763
	spin_unlock(&root->inode_lock);
4764

4765 4766 4767 4768 4769 4770 4771 4772
	/*
	 * Free space cache has inodes in the tree root, but the tree root has a
	 * root_refs of 0, so this could end up dropping the tree root as a
	 * snapshot, so we need the extra !root->fs_info->tree_root check to
	 * make sure we don't drop it.
	 */
	if (empty && btrfs_root_refs(&root->root_item) == 0 &&
	    root != root->fs_info->tree_root) {
4773 4774 4775 4776 4777 4778 4779 4780 4781
		synchronize_srcu(&root->fs_info->subvol_srcu);
		spin_lock(&root->inode_lock);
		empty = RB_EMPTY_ROOT(&root->inode_tree);
		spin_unlock(&root->inode_lock);
		if (empty)
			btrfs_add_dead_root(root);
	}
}

4782
void btrfs_invalidate_inodes(struct btrfs_root *root)
4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
{
	struct rb_node *node;
	struct rb_node *prev;
	struct btrfs_inode *entry;
	struct inode *inode;
	u64 objectid = 0;

	WARN_ON(btrfs_root_refs(&root->root_item) != 0);

	spin_lock(&root->inode_lock);
again:
	node = root->inode_tree.rb_node;
	prev = NULL;
	while (node) {
		prev = node;
		entry = rb_entry(node, struct btrfs_inode, rb_node);

L
Li Zefan 已提交
4800
		if (objectid < btrfs_ino(&entry->vfs_inode))
4801
			node = node->rb_left;
L
Li Zefan 已提交
4802
		else if (objectid > btrfs_ino(&entry->vfs_inode))
4803 4804 4805 4806 4807 4808 4809
			node = node->rb_right;
		else
			break;
	}
	if (!node) {
		while (prev) {
			entry = rb_entry(prev, struct btrfs_inode, rb_node);
L
Li Zefan 已提交
4810
			if (objectid <= btrfs_ino(&entry->vfs_inode)) {
4811 4812 4813 4814 4815 4816 4817 4818
				node = prev;
				break;
			}
			prev = rb_next(prev);
		}
	}
	while (node) {
		entry = rb_entry(node, struct btrfs_inode, rb_node);
L
Li Zefan 已提交
4819
		objectid = btrfs_ino(&entry->vfs_inode) + 1;
4820 4821 4822 4823 4824 4825
		inode = igrab(&entry->vfs_inode);
		if (inode) {
			spin_unlock(&root->inode_lock);
			if (atomic_read(&inode->i_count) > 1)
				d_prune_aliases(inode);
			/*
4826
			 * btrfs_drop_inode will have it removed from
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841
			 * the inode cache when its usage count
			 * hits zero.
			 */
			iput(inode);
			cond_resched();
			spin_lock(&root->inode_lock);
			goto again;
		}

		if (cond_resched_lock(&root->inode_lock))
			goto again;

		node = rb_next(node);
	}
	spin_unlock(&root->inode_lock);
4842 4843
}

4844 4845 4846 4847 4848
static int btrfs_init_locked_inode(struct inode *inode, void *p)
{
	struct btrfs_iget_args *args = p;
	inode->i_ino = args->ino;
	BTRFS_I(inode)->root = args->root;
C
Chris Mason 已提交
4849 4850 4851 4852 4853 4854
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
L
Li Zefan 已提交
4855
	return args->ino == btrfs_ino(inode) &&
C
Chris Mason 已提交
4856
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
4857 4858
}

4859 4860 4861
static struct inode *btrfs_iget_locked(struct super_block *s,
				       u64 objectid,
				       struct btrfs_root *root)
C
Chris Mason 已提交
4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873
{
	struct inode *inode;
	struct btrfs_iget_args args;
	args.ino = objectid;
	args.root = root;

	inode = iget5_locked(s, objectid, btrfs_find_actor,
			     btrfs_init_locked_inode,
			     (void *)&args);
	return inode;
}

B
Balaji Rao 已提交
4874 4875 4876 4877
/* Get an inode object given its location and corresponding root.
 * Returns in *is_new if the inode was read from disk
 */
struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
4878
			 struct btrfs_root *root, int *new)
B
Balaji Rao 已提交
4879 4880 4881 4882 4883
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
4884
		return ERR_PTR(-ENOMEM);
B
Balaji Rao 已提交
4885 4886 4887 4888 4889

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
4890 4891 4892 4893 4894 4895
		if (!is_bad_inode(inode)) {
			inode_tree_add(inode);
			unlock_new_inode(inode);
			if (new)
				*new = 1;
		} else {
4896 4897 4898
			unlock_new_inode(inode);
			iput(inode);
			inode = ERR_PTR(-ESTALE);
4899 4900 4901
		}
	}

B
Balaji Rao 已提交
4902 4903 4904
	return inode;
}

4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915
static struct inode *new_simple_dir(struct super_block *s,
				    struct btrfs_key *key,
				    struct btrfs_root *root)
{
	struct inode *inode = new_inode(s);

	if (!inode)
		return ERR_PTR(-ENOMEM);

	BTRFS_I(inode)->root = root;
	memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
4916
	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
4917 4918

	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
L
Li Zefan 已提交
4919
	inode->i_op = &btrfs_dir_ro_inode_operations;
4920 4921 4922 4923 4924 4925 4926
	inode->i_fop = &simple_dir_operations;
	inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

	return inode;
}

4927
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
4928
{
C
Chris Mason 已提交
4929
	struct inode *inode;
4930
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
4931 4932
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
4933
	int index;
4934
	int ret = 0;
C
Chris Mason 已提交
4935 4936 4937

	if (dentry->d_name.len > BTRFS_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);
4938

J
Jeff Layton 已提交
4939
	ret = btrfs_inode_by_name(dir, dentry, &location);
C
Chris Mason 已提交
4940 4941
	if (ret < 0)
		return ERR_PTR(ret);
4942

4943 4944 4945 4946
	if (location.objectid == 0)
		return NULL;

	if (location.type == BTRFS_INODE_ITEM_KEY) {
4947
		inode = btrfs_iget(dir->i_sb, &location, root, NULL);
4948 4949 4950 4951 4952
		return inode;
	}

	BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);

4953
	index = srcu_read_lock(&root->fs_info->subvol_srcu);
4954 4955 4956 4957 4958 4959 4960 4961
	ret = fixup_tree_root_location(root, dir, dentry,
				       &location, &sub_root);
	if (ret < 0) {
		if (ret != -ENOENT)
			inode = ERR_PTR(ret);
		else
			inode = new_simple_dir(dir->i_sb, &location, sub_root);
	} else {
4962
		inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
C
Chris Mason 已提交
4963
	}
4964 4965
	srcu_read_unlock(&root->fs_info->subvol_srcu, index);

4966
	if (!IS_ERR(inode) && root != sub_root) {
4967 4968
		down_read(&root->fs_info->cleanup_work_sem);
		if (!(inode->i_sb->s_flags & MS_RDONLY))
4969
			ret = btrfs_orphan_cleanup(sub_root);
4970
		up_read(&root->fs_info->cleanup_work_sem);
4971 4972
		if (ret) {
			iput(inode);
4973
			inode = ERR_PTR(ret);
4974
		}
4975 4976
	}

4977 4978 4979
	return inode;
}

N
Nick Piggin 已提交
4980
static int btrfs_dentry_delete(const struct dentry *dentry)
4981 4982
{
	struct btrfs_root *root;
L
Li Zefan 已提交
4983
	struct inode *inode = dentry->d_inode;
4984

L
Li Zefan 已提交
4985 4986
	if (!inode && !IS_ROOT(dentry))
		inode = dentry->d_parent->d_inode;
4987

L
Li Zefan 已提交
4988 4989
	if (inode) {
		root = BTRFS_I(inode)->root;
4990 4991
		if (btrfs_root_refs(&root->root_item) == 0)
			return 1;
L
Li Zefan 已提交
4992 4993 4994

		if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
			return 1;
4995
	}
4996 4997 4998
	return 0;
}

4999 5000 5001 5002 5003 5004
static void btrfs_dentry_release(struct dentry *dentry)
{
	if (dentry->d_fsdata)
		kfree(dentry->d_fsdata);
}

5005
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
5006
				   unsigned int flags)
5007
{
5008 5009 5010 5011
	struct dentry *ret;

	ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
	return ret;
C
Chris Mason 已提交
5012 5013
}

5014
unsigned char btrfs_filetype_table[] = {
C
Chris Mason 已提交
5015 5016 5017
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

5018 5019
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
5020
{
A
Al Viro 已提交
5021
	struct inode *inode = file_inode(filp);
C
Chris Mason 已提交
5022 5023 5024 5025
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
5026
	struct btrfs_key found_key;
C
Chris Mason 已提交
5027
	struct btrfs_path *path;
5028 5029
	struct list_head ins_list;
	struct list_head del_list;
C
Chris Mason 已提交
5030
	int ret;
5031
	struct extent_buffer *leaf;
C
Chris Mason 已提交
5032 5033 5034 5035 5036 5037 5038
	int slot;
	unsigned char d_type;
	int over = 0;
	u32 di_cur;
	u32 di_total;
	u32 di_len;
	int key_type = BTRFS_DIR_INDEX_KEY;
5039 5040 5041
	char tmp_name[32];
	char *name_ptr;
	int name_len;
5042
	int is_curr = 0;	/* filp->f_pos points to the current index? */
C
Chris Mason 已提交
5043 5044 5045 5046

	/* FIXME, use a real flag for deciding about the key type */
	if (root->fs_info->tree_root == root)
		key_type = BTRFS_DIR_ITEM_KEY;
5047

5048 5049
	/* special case for "." */
	if (filp->f_pos == 0) {
5050 5051
		over = filldir(dirent, ".", 1,
			       filp->f_pos, btrfs_ino(inode), DT_DIR);
5052 5053 5054 5055 5056 5057
		if (over)
			return 0;
		filp->f_pos = 1;
	}
	/* special case for .., just use the back ref */
	if (filp->f_pos == 1) {
5058
		u64 pino = parent_ino(filp->f_path.dentry);
5059
		over = filldir(dirent, "..", 2,
5060
			       filp->f_pos, pino, DT_DIR);
5061
		if (over)
5062
			return 0;
5063 5064
		filp->f_pos = 2;
	}
5065
	path = btrfs_alloc_path();
5066 5067
	if (!path)
		return -ENOMEM;
C
Chris Mason 已提交
5068

J
Josef Bacik 已提交
5069
	path->reada = 1;
5070

5071 5072 5073 5074 5075 5076
	if (key_type == BTRFS_DIR_INDEX_KEY) {
		INIT_LIST_HEAD(&ins_list);
		INIT_LIST_HEAD(&del_list);
		btrfs_get_delayed_items(inode, &ins_list, &del_list);
	}

C
Chris Mason 已提交
5077 5078
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
L
Li Zefan 已提交
5079
	key.objectid = btrfs_ino(inode);
5080

C
Chris Mason 已提交
5081 5082 5083
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
5084 5085

	while (1) {
5086
		leaf = path->nodes[0];
C
Chris Mason 已提交
5087
		slot = path->slots[0];
5088 5089 5090 5091 5092 5093 5094
		if (slot >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto err;
			else if (ret > 0)
				break;
			continue;
C
Chris Mason 已提交
5095
		}
5096

5097 5098 5099 5100
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
5101
			break;
5102
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
5103
			break;
5104
		if (found_key.offset < filp->f_pos)
5105
			goto next;
5106 5107 5108 5109
		if (key_type == BTRFS_DIR_INDEX_KEY &&
		    btrfs_should_delete_dir_index(&del_list,
						  found_key.offset))
			goto next;
5110 5111

		filp->f_pos = found_key.offset;
5112
		is_curr = 1;
5113

C
Chris Mason 已提交
5114 5115
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
5116
		di_total = btrfs_item_size(leaf, item);
5117 5118

		while (di_cur < di_total) {
5119 5120
			struct btrfs_key location;

5121 5122 5123
			if (verify_dir_item(root, leaf, di))
				break;

5124
			name_len = btrfs_dir_name_len(leaf, di);
5125
			if (name_len <= sizeof(tmp_name)) {
5126 5127 5128
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
5129 5130 5131 5132
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
5133 5134 5135 5136 5137 5138
			}
			read_extent_buffer(leaf, name_ptr,
					   (unsigned long)(di + 1), name_len);

			d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
			btrfs_dir_item_key_to_cpu(leaf, di, &location);
5139

5140

5141
			/* is this a reference to our own snapshot? If so
A
Arne Jansen 已提交
5142 5143 5144 5145 5146 5147 5148
			 * skip it.
			 *
			 * In contrast to old kernels, we insert the snapshot's
			 * dir item and dir index after it has been created, so
			 * we won't find a reference to our own snapshot. We
			 * still keep the following code for backward
			 * compatibility.
5149 5150 5151 5152 5153 5154
			 */
			if (location.type == BTRFS_ROOT_ITEM_KEY &&
			    location.objectid == root->root_key.objectid) {
				over = 0;
				goto skip;
			}
5155
			over = filldir(dirent, name_ptr, name_len,
5156
				       found_key.offset, location.objectid,
C
Chris Mason 已提交
5157
				       d_type);
5158

5159
skip:
5160 5161 5162
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
5163 5164
			if (over)
				goto nopos;
J
Josef Bacik 已提交
5165
			di_len = btrfs_dir_name_len(leaf, di) +
5166
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
5167 5168 5169
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
5170 5171
next:
		path->slots[0]++;
C
Chris Mason 已提交
5172
	}
5173

5174 5175 5176 5177 5178 5179 5180 5181 5182
	if (key_type == BTRFS_DIR_INDEX_KEY) {
		if (is_curr)
			filp->f_pos++;
		ret = btrfs_readdir_delayed_dir_index(filp, dirent, filldir,
						      &ins_list);
		if (ret)
			goto nopos;
	}

5183
	/* Reached end of directory/root. Bump pos past the last item. */
5184
	if (key_type == BTRFS_DIR_INDEX_KEY)
5185 5186 5187 5188 5189
		/*
		 * 32-bit glibc will use getdents64, but then strtol -
		 * so the last number we can serve is this.
		 */
		filp->f_pos = 0x7fffffff;
5190 5191
	else
		filp->f_pos++;
C
Chris Mason 已提交
5192 5193 5194
nopos:
	ret = 0;
err:
5195 5196
	if (key_type == BTRFS_DIR_INDEX_KEY)
		btrfs_put_delayed_items(&ins_list, &del_list);
C
Chris Mason 已提交
5197 5198 5199 5200
	btrfs_free_path(path);
	return ret;
}

5201
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
C
Chris Mason 已提交
5202 5203 5204 5205
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;
5206
	bool nolock = false;
C
Chris Mason 已提交
5207

5208
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5209 5210
		return 0;

5211
	if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
5212
		nolock = true;
5213

5214
	if (wbc->sync_mode == WB_SYNC_ALL) {
5215
		if (nolock)
5216
			trans = btrfs_join_transaction_nolock(root);
5217
		else
5218
			trans = btrfs_join_transaction(root);
5219 5220
		if (IS_ERR(trans))
			return PTR_ERR(trans);
5221
		ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
5222 5223 5224 5225 5226
	}
	return ret;
}

/*
5227
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
5228 5229 5230 5231
 * inode changes.  But, it is most likely to find the inode in cache.
 * FIXME, needs more benchmarking...there are no reasons other than performance
 * to keep or drop this code.
 */
5232
static int btrfs_dirty_inode(struct inode *inode)
C
Chris Mason 已提交
5233 5234 5235
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
5236 5237
	int ret;

5238
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5239
		return 0;
C
Chris Mason 已提交
5240

5241
	trans = btrfs_join_transaction(root);
5242 5243
	if (IS_ERR(trans))
		return PTR_ERR(trans);
5244 5245

	ret = btrfs_update_inode(trans, root, inode);
5246 5247 5248 5249
	if (ret && ret == -ENOSPC) {
		/* whoops, lets try again with the full transaction */
		btrfs_end_transaction(trans, root);
		trans = btrfs_start_transaction(root, 1);
5250 5251
		if (IS_ERR(trans))
			return PTR_ERR(trans);
5252

5253 5254
		ret = btrfs_update_inode(trans, root, inode);
	}
C
Chris Mason 已提交
5255
	btrfs_end_transaction(trans, root);
5256 5257
	if (BTRFS_I(inode)->delayed_node)
		btrfs_balance_delayed_items(root);
5258 5259 5260 5261 5262 5263 5264 5265

	return ret;
}

/*
 * This is a copy of file_update_time.  We need this so we can return error on
 * ENOSPC for updating the inode in the case of file write and mmap writes.
 */
5266 5267
static int btrfs_update_time(struct inode *inode, struct timespec *now,
			     int flags)
5268
{
5269 5270 5271 5272 5273
	struct btrfs_root *root = BTRFS_I(inode)->root;

	if (btrfs_root_readonly(root))
		return -EROFS;

5274
	if (flags & S_VERSION)
5275
		inode_inc_iversion(inode);
5276 5277 5278 5279 5280 5281 5282
	if (flags & S_CTIME)
		inode->i_ctime = *now;
	if (flags & S_MTIME)
		inode->i_mtime = *now;
	if (flags & S_ATIME)
		inode->i_atime = *now;
	return btrfs_dirty_inode(inode);
C
Chris Mason 已提交
5283 5284
}

C
Chris Mason 已提交
5285 5286 5287 5288 5289
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
5290 5291 5292 5293 5294 5295 5296 5297
static int btrfs_set_inode_index_count(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key key, found_key;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	int ret;

L
Li Zefan 已提交
5298
	key.objectid = btrfs_ino(inode);
5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329
	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	key.offset = (u64)-1;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto out;
	/* FIXME: we should be able to handle this */
	if (ret == 0)
		goto out;
	ret = 0;

	/*
	 * MAGIC NUMBER EXPLANATION:
	 * since we search a directory based on f_pos we have to start at 2
	 * since '.' and '..' have f_pos of 0 and 1 respectively, so everybody
	 * else has to start at 2
	 */
	if (path->slots[0] == 0) {
		BTRFS_I(inode)->index_cnt = 2;
		goto out;
	}

	path->slots[0]--;

	leaf = path->nodes[0];
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

L
Li Zefan 已提交
5330
	if (found_key.objectid != btrfs_ino(inode) ||
5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341
	    btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
		BTRFS_I(inode)->index_cnt = 2;
		goto out;
	}

	BTRFS_I(inode)->index_cnt = found_key.offset + 1;
out:
	btrfs_free_path(path);
	return ret;
}

C
Chris Mason 已提交
5342 5343 5344 5345
/*
 * helper to find a free sequence number in a given directory.  This current
 * code is very simple, later versions will do smarter things in the btree
 */
5346
int btrfs_set_inode_index(struct inode *dir, u64 *index)
5347 5348 5349 5350
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
5351 5352 5353 5354 5355 5356
		ret = btrfs_inode_delayed_dir_index_count(dir);
		if (ret) {
			ret = btrfs_set_inode_index_count(dir);
			if (ret)
				return ret;
		}
5357 5358
	}

5359
	*index = BTRFS_I(dir)->index_cnt;
5360 5361 5362 5363 5364
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
5365 5366
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
5367
				     struct inode *dir,
5368
				     const char *name, int name_len,
A
Al Viro 已提交
5369 5370
				     u64 ref_objectid, u64 objectid,
				     umode_t mode, u64 *index)
C
Chris Mason 已提交
5371 5372
{
	struct inode *inode;
5373
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
5374
	struct btrfs_key *location;
5375
	struct btrfs_path *path;
5376 5377 5378 5379
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
5380 5381 5382
	int ret;
	int owner;

5383
	path = btrfs_alloc_path();
5384 5385
	if (!path)
		return ERR_PTR(-ENOMEM);
5386

C
Chris Mason 已提交
5387
	inode = new_inode(root->fs_info->sb);
5388 5389
	if (!inode) {
		btrfs_free_path(path);
C
Chris Mason 已提交
5390
		return ERR_PTR(-ENOMEM);
5391
	}
C
Chris Mason 已提交
5392

5393 5394 5395 5396 5397 5398
	/*
	 * we have to initialize this early, so we can reclaim the inode
	 * number if we fail afterwards in this function.
	 */
	inode->i_ino = objectid;

5399
	if (dir) {
5400 5401
		trace_btrfs_inode_request(dir);

5402
		ret = btrfs_set_inode_index(dir, index);
5403
		if (ret) {
5404
			btrfs_free_path(path);
5405
			iput(inode);
5406
			return ERR_PTR(ret);
5407
		}
5408 5409 5410 5411 5412 5413 5414
	}
	/*
	 * index_cnt is ignored for everything but a dir,
	 * btrfs_get_inode_index_count has an explanation for the magic
	 * number
	 */
	BTRFS_I(inode)->index_cnt = 2;
C
Chris Mason 已提交
5415
	BTRFS_I(inode)->root = root;
5416
	BTRFS_I(inode)->generation = trans->transid;
5417
	inode->i_generation = BTRFS_I(inode)->generation;
5418

J
Josef Bacik 已提交
5419 5420 5421 5422 5423 5424 5425 5426
	/*
	 * We could have gotten an inode number from somebody who was fsynced
	 * and then removed in this same transaction, so let's just set full
	 * sync since it will be a full sync anyway and this will blow away the
	 * old info in the log.
	 */
	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);

5427
	if (S_ISDIR(mode))
C
Chris Mason 已提交
5428 5429 5430
		owner = 0;
	else
		owner = 1;
5431 5432 5433 5434 5435

	key[0].objectid = objectid;
	btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
	key[0].offset = 0;

M
Mark Fasheh 已提交
5436 5437 5438 5439 5440 5441
	/*
	 * Start new inodes with an inode_ref. This is slightly more
	 * efficient for small numbers of hard links since they will
	 * be packed into one item. Extended refs will kick in if we
	 * add more hard links than can fit in the ref item.
	 */
5442 5443 5444 5445 5446 5447 5448
	key[1].objectid = objectid;
	btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
	key[1].offset = ref_objectid;

	sizes[0] = sizeof(struct btrfs_inode_item);
	sizes[1] = name_len + sizeof(*ref);

5449
	path->leave_spinning = 1;
5450 5451
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
5452 5453
		goto fail;

5454
	inode_init_owner(inode, dir, mode);
5455
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
5456
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
5457 5458
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
5459 5460
	memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
			     sizeof(*inode_item));
5461
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
5462 5463 5464 5465

	ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
			     struct btrfs_inode_ref);
	btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
5466
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
5467 5468 5469
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

5470 5471 5472
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
5473 5474 5475 5476 5477
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

5478 5479
	btrfs_inherit_iflags(inode, dir);

5480
	if (S_ISREG(mode)) {
5481 5482
		if (btrfs_test_opt(root, NODATASUM))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
L
Liu Bo 已提交
5483
		if (btrfs_test_opt(root, NODATACOW))
5484 5485
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |
				BTRFS_INODE_NODATASUM;
5486 5487
	}

C
Chris Mason 已提交
5488
	insert_inode_hash(inode);
5489
	inode_tree_add(inode);
5490 5491

	trace_btrfs_inode_new(inode);
5492
	btrfs_set_inode_last_trans(trans, inode);
5493

5494 5495
	btrfs_update_root_times(trans, root);

C
Chris Mason 已提交
5496
	return inode;
5497
fail:
5498 5499
	if (dir)
		BTRFS_I(dir)->index_cnt--;
5500
	btrfs_free_path(path);
5501
	iput(inode);
5502
	return ERR_PTR(ret);
C
Chris Mason 已提交
5503 5504 5505 5506 5507 5508 5509
}

static inline u8 btrfs_inode_type(struct inode *inode)
{
	return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
}

C
Chris Mason 已提交
5510 5511 5512 5513 5514 5515
/*
 * utility function to add 'inode' into 'parent_inode' with
 * a give name and a given sequence number.
 * if 'add_backref' is true, also insert a backref from the
 * inode to the parent directory.
 */
5516 5517 5518
int btrfs_add_link(struct btrfs_trans_handle *trans,
		   struct inode *parent_inode, struct inode *inode,
		   const char *name, int name_len, int add_backref, u64 index)
C
Chris Mason 已提交
5519
{
5520
	int ret = 0;
C
Chris Mason 已提交
5521
	struct btrfs_key key;
5522
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
L
Li Zefan 已提交
5523 5524
	u64 ino = btrfs_ino(inode);
	u64 parent_ino = btrfs_ino(parent_inode);
5525

L
Li Zefan 已提交
5526
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5527 5528
		memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
	} else {
L
Li Zefan 已提交
5529
		key.objectid = ino;
5530 5531 5532 5533
		btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
		key.offset = 0;
	}

L
Li Zefan 已提交
5534
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5535 5536
		ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
					 key.objectid, root->root_key.objectid,
L
Li Zefan 已提交
5537
					 parent_ino, index, name, name_len);
5538
	} else if (add_backref) {
L
Li Zefan 已提交
5539 5540
		ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
					     parent_ino, index);
5541
	}
C
Chris Mason 已提交
5542

5543 5544 5545
	/* Nothing to clean up yet */
	if (ret)
		return ret;
5546

5547 5548 5549
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode, &key,
				    btrfs_inode_type(inode), index);
C
Chris Mason 已提交
5550
	if (ret == -EEXIST || ret == -EOVERFLOW)
5551 5552 5553 5554
		goto fail_dir_item;
	else if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		return ret;
C
Chris Mason 已提交
5555
	}
5556 5557 5558

	btrfs_i_size_write(parent_inode, parent_inode->i_size +
			   name_len * 2);
5559
	inode_inc_iversion(parent_inode);
5560 5561 5562 5563
	parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
	ret = btrfs_update_inode(trans, root, parent_inode);
	if (ret)
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
5564
	return ret;
5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581

fail_dir_item:
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
		u64 local_index;
		int err;
		err = btrfs_del_root_ref(trans, root->fs_info->tree_root,
				 key.objectid, root->root_key.objectid,
				 parent_ino, &local_index, name, name_len);

	} else if (add_backref) {
		u64 local_index;
		int err;

		err = btrfs_del_inode_ref(trans, root, name, name_len,
					  ino, parent_ino, &local_index);
	}
	return ret;
C
Chris Mason 已提交
5582 5583 5584
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
5585 5586
			    struct inode *dir, struct dentry *dentry,
			    struct inode *inode, int backref, u64 index)
C
Chris Mason 已提交
5587
{
5588 5589 5590
	int err = btrfs_add_link(trans, dir, inode,
				 dentry->d_name.name, dentry->d_name.len,
				 backref, index);
C
Chris Mason 已提交
5591 5592 5593 5594 5595
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
5596
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
5597
			umode_t mode, dev_t rdev)
J
Josef Bacik 已提交
5598 5599 5600
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
5601
	struct inode *inode = NULL;
J
Josef Bacik 已提交
5602 5603 5604
	int err;
	int drop_inode = 0;
	u64 objectid;
5605
	u64 index = 0;
J
Josef Bacik 已提交
5606 5607 5608 5609

	if (!new_valid_dev(rdev))
		return -EINVAL;

J
Josef Bacik 已提交
5610 5611 5612 5613 5614
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
5615 5616 5617
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
5618

5619 5620 5621 5622
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

5623
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5624
				dentry->d_name.len, btrfs_ino(dir), objectid,
5625
				mode, &index);
5626 5627
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
J
Josef Bacik 已提交
5628
		goto out_unlock;
5629
	}
J
Josef Bacik 已提交
5630

5631
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
5632 5633 5634 5635 5636
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

5637 5638 5639 5640 5641 5642 5643 5644
	/*
	* If the active LSM wants to access the inode during
	* d_instantiate it needs these. Smack checks to see
	* if the filesystem supports xattrs by looking at the
	* ops vector.
	*/

	inode->i_op = &btrfs_special_inode_operations;
5645
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
J
Josef Bacik 已提交
5646 5647 5648 5649
	if (err)
		drop_inode = 1;
	else {
		init_special_inode(inode, inode->i_mode, rdev);
5650
		btrfs_update_inode(trans, root, inode);
5651
		d_instantiate(dentry, inode);
J
Josef Bacik 已提交
5652 5653
	}
out_unlock:
5654
	btrfs_end_transaction(trans, root);
5655
	btrfs_btree_balance_dirty(root);
J
Josef Bacik 已提交
5656 5657 5658 5659 5660 5661 5662
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
	return err;
}

C
Chris Mason 已提交
5663
static int btrfs_create(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
5664
			umode_t mode, bool excl)
C
Chris Mason 已提交
5665 5666 5667
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
5668
	struct inode *inode = NULL;
5669
	int drop_inode_on_err = 0;
5670
	int err;
C
Chris Mason 已提交
5671
	u64 objectid;
5672
	u64 index = 0;
C
Chris Mason 已提交
5673

J
Josef Bacik 已提交
5674 5675 5676 5677 5678
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
5679 5680 5681
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
J
Josef Bacik 已提交
5682

5683 5684 5685 5686
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

5687
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5688
				dentry->d_name.len, btrfs_ino(dir), objectid,
5689
				mode, &index);
5690 5691
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
5692
		goto out_unlock;
5693
	}
5694
	drop_inode_on_err = 1;
C
Chris Mason 已提交
5695

5696
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5697
	if (err)
J
Josef Bacik 已提交
5698 5699
		goto out_unlock;

5700 5701 5702 5703
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_unlock;

5704 5705 5706 5707 5708 5709 5710 5711 5712
	/*
	* If the active LSM wants to access the inode during
	* d_instantiate it needs these. Smack checks to see
	* if the filesystem supports xattrs by looking at the
	* ops vector.
	*/
	inode->i_fop = &btrfs_file_operations;
	inode->i_op = &btrfs_file_inode_operations;

5713
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
5714
	if (err)
5715 5716 5717 5718 5719 5720 5721
		goto out_unlock;

	inode->i_mapping->a_ops = &btrfs_aops;
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
	BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
	d_instantiate(dentry, inode);

C
Chris Mason 已提交
5722
out_unlock:
5723
	btrfs_end_transaction(trans, root);
5724
	if (err && drop_inode_on_err) {
C
Chris Mason 已提交
5725 5726 5727
		inode_dec_link_count(inode);
		iput(inode);
	}
5728
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5729 5730 5731 5732 5733 5734 5735 5736 5737
	return err;
}

static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
		      struct dentry *dentry)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct inode *inode = old_dentry->d_inode;
5738
	u64 index;
C
Chris Mason 已提交
5739 5740 5741
	int err;
	int drop_inode = 0;

5742 5743
	/* do not allow sys_link's with other subvols of the same device */
	if (root->objectid != BTRFS_I(inode)->root->objectid)
5744
		return -EXDEV;
5745

M
Mark Fasheh 已提交
5746
	if (inode->i_nlink >= BTRFS_LINK_MAX)
5747
		return -EMLINK;
5748

5749
	err = btrfs_set_inode_index(dir, &index);
5750 5751 5752
	if (err)
		goto fail;

5753
	/*
M
Miao Xie 已提交
5754
	 * 2 items for inode and inode ref
5755
	 * 2 items for dir items
M
Miao Xie 已提交
5756
	 * 1 item for parent inode
5757
	 */
M
Miao Xie 已提交
5758
	trans = btrfs_start_transaction(root, 5);
5759 5760 5761 5762
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto fail;
	}
5763

5764
	btrfs_inc_nlink(inode);
5765
	inode_inc_iversion(inode);
5766
	inode->i_ctime = CURRENT_TIME;
A
Al Viro 已提交
5767
	ihold(inode);
5768
	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
5769

5770
	err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
5771

5772
	if (err) {
5773
		drop_inode = 1;
5774
	} else {
5775
		struct dentry *parent = dentry->d_parent;
5776
		err = btrfs_update_inode(trans, root, inode);
5777 5778
		if (err)
			goto fail;
5779
		d_instantiate(dentry, inode);
5780
		btrfs_log_new_name(trans, inode, NULL, parent);
5781
	}
C
Chris Mason 已提交
5782

5783
	btrfs_end_transaction(trans, root);
5784
fail:
C
Chris Mason 已提交
5785 5786 5787 5788
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
5789
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5790 5791 5792
	return err;
}

5793
static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
C
Chris Mason 已提交
5794
{
5795
	struct inode *inode = NULL;
C
Chris Mason 已提交
5796 5797 5798 5799
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
5800
	u64 objectid = 0;
5801
	u64 index = 0;
C
Chris Mason 已提交
5802

J
Josef Bacik 已提交
5803 5804 5805 5806 5807
	/*
	 * 2 items for inode and ref
	 * 2 items for dir items
	 * 1 for xattr if selinux is on
	 */
5808 5809 5810
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
5811

5812 5813 5814 5815
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_fail;

5816
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5817
				dentry->d_name.len, btrfs_ino(dir), objectid,
5818
				S_IFDIR | mode, &index);
C
Chris Mason 已提交
5819 5820 5821 5822
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
5823

C
Chris Mason 已提交
5824
	drop_on_err = 1;
J
Josef Bacik 已提交
5825

5826
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
5827 5828 5829
	if (err)
		goto out_fail;

C
Chris Mason 已提交
5830 5831 5832
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

5833
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
5834 5835 5836
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
5837

5838 5839
	err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
			     dentry->d_name.len, 0, index);
C
Chris Mason 已提交
5840 5841
	if (err)
		goto out_fail;
5842

C
Chris Mason 已提交
5843 5844 5845 5846
	d_instantiate(dentry, inode);
	drop_on_err = 0;

out_fail:
5847
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
5848 5849
	if (drop_on_err)
		iput(inode);
5850
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5851 5852 5853
	return err;
}

C
Chris Mason 已提交
5854 5855 5856 5857
/* helper for btfs_get_extent.  Given an existing extent in the tree,
 * and an extent that you want to insert, deal with overlap and insert
 * the new extent into the tree.
 */
5858 5859
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
5860 5861
				struct extent_map *em,
				u64 map_start, u64 map_len)
5862 5863 5864
{
	u64 start_diff;

5865 5866 5867 5868
	BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
	start_diff = map_start - em->start;
	em->start = map_start;
	em->len = map_len;
C
Chris Mason 已提交
5869 5870
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
5871
		em->block_start += start_diff;
C
Chris Mason 已提交
5872 5873
		em->block_len -= start_diff;
	}
J
Josef Bacik 已提交
5874
	return add_extent_mapping(em_tree, em, 0);
5875 5876
}

C
Chris Mason 已提交
5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887
static noinline int uncompress_inline(struct btrfs_path *path,
				      struct inode *inode, struct page *page,
				      size_t pg_offset, u64 extent_offset,
				      struct btrfs_file_extent_item *item)
{
	int ret;
	struct extent_buffer *leaf = path->nodes[0];
	char *tmp;
	size_t max_size;
	unsigned long inline_size;
	unsigned long ptr;
5888
	int compress_type;
C
Chris Mason 已提交
5889 5890

	WARN_ON(pg_offset != 0);
5891
	compress_type = btrfs_file_extent_compression(leaf, item);
C
Chris Mason 已提交
5892 5893 5894 5895
	max_size = btrfs_file_extent_ram_bytes(leaf, item);
	inline_size = btrfs_file_extent_inline_item_len(leaf,
					btrfs_item_nr(leaf, path->slots[0]));
	tmp = kmalloc(inline_size, GFP_NOFS);
5896 5897
	if (!tmp)
		return -ENOMEM;
C
Chris Mason 已提交
5898 5899 5900 5901
	ptr = btrfs_file_extent_inline_start(item);

	read_extent_buffer(leaf, tmp, ptr, inline_size);

5902
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
5903 5904
	ret = btrfs_decompress(compress_type, tmp, page,
			       extent_offset, inline_size, max_size);
C
Chris Mason 已提交
5905
	if (ret) {
5906
		char *kaddr = kmap_atomic(page);
C
Chris Mason 已提交
5907 5908 5909 5910
		unsigned long copy_size = min_t(u64,
				  PAGE_CACHE_SIZE - pg_offset,
				  max_size - extent_offset);
		memset(kaddr + pg_offset, 0, copy_size);
5911
		kunmap_atomic(kaddr);
C
Chris Mason 已提交
5912 5913 5914 5915 5916
	}
	kfree(tmp);
	return 0;
}

C
Chris Mason 已提交
5917 5918
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
C
Chris Mason 已提交
5919 5920
 * the ugly parts come from merging extents from the disk with the in-ram
 * representation.  This gets more complex because of the data=ordered code,
C
Chris Mason 已提交
5921 5922 5923 5924
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
C
Chris Mason 已提交
5925

5926
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
5927
				    size_t pg_offset, u64 start, u64 len,
5928 5929 5930 5931
				    int create)
{
	int ret;
	int err = 0;
5932
	u64 bytenr;
5933 5934
	u64 extent_start = 0;
	u64 extent_end = 0;
L
Li Zefan 已提交
5935
	u64 objectid = btrfs_ino(inode);
5936
	u32 found_type;
5937
	struct btrfs_path *path = NULL;
5938 5939
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
5940 5941
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
5942 5943
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5944
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
5945
	struct btrfs_trans_handle *trans = NULL;
5946
	int compress_type;
5947 5948

again:
5949
	read_lock(&em_tree->lock);
5950
	em = lookup_extent_mapping(em_tree, start, len);
5951 5952
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
5953
	read_unlock(&em_tree->lock);
5954

5955
	if (em) {
5956 5957 5958
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
5959 5960 5961
			free_extent_map(em);
		else
			goto out;
5962
	}
5963
	em = alloc_extent_map();
5964
	if (!em) {
5965 5966
		err = -ENOMEM;
		goto out;
5967
	}
5968
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5969
	em->start = EXTENT_MAP_HOLE;
5970
	em->orig_start = EXTENT_MAP_HOLE;
5971
	em->len = (u64)-1;
C
Chris Mason 已提交
5972
	em->block_len = (u64)-1;
5973 5974 5975

	if (!path) {
		path = btrfs_alloc_path();
J
Josef Bacik 已提交
5976 5977 5978 5979 5980 5981 5982 5983 5984
		if (!path) {
			err = -ENOMEM;
			goto out;
		}
		/*
		 * Chances are we'll be called again, so go ahead and do
		 * readahead
		 */
		path->reada = 1;
5985 5986
	}

5987 5988
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999
	if (ret < 0) {
		err = ret;
		goto out;
	}

	if (ret != 0) {
		if (path->slots[0] == 0)
			goto not_found;
		path->slots[0]--;
	}

6000 6001
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
6002 6003
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
6004 6005 6006
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
6007 6008 6009 6010
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

6011 6012
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
6013
	compress_type = btrfs_file_extent_compression(leaf, item);
Y
Yan Zheng 已提交
6014 6015
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
6016
		extent_end = extent_start +
6017
		       btrfs_file_extent_num_bytes(leaf, item);
Y
Yan Zheng 已提交
6018 6019 6020
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
		size_t size;
		size = btrfs_file_extent_inline_len(leaf, item);
6021
		extent_end = ALIGN(extent_start + size, root->sectorsize);
Y
Yan Zheng 已提交
6022 6023 6024 6025 6026 6027 6028 6029 6030
	}

	if (start >= extent_end) {
		path->slots[0]++;
		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0) {
				err = ret;
				goto out;
6031
			}
Y
Yan Zheng 已提交
6032 6033 6034
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
6035
		}
Y
Yan Zheng 已提交
6036 6037 6038 6039 6040 6041 6042
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		if (found_key.objectid != objectid ||
		    found_key.type != BTRFS_EXTENT_DATA_KEY)
			goto not_found;
		if (start + len <= found_key.offset)
			goto not_found;
		em->start = start;
6043
		em->orig_start = start;
Y
Yan Zheng 已提交
6044 6045 6046 6047
		em->len = found_key.offset - start;
		goto not_found_em;
	}

J
Josef Bacik 已提交
6048
	em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, item);
Y
Yan Zheng 已提交
6049 6050
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
6051 6052
		em->start = extent_start;
		em->len = extent_end - extent_start;
6053 6054
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
6055 6056
		em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
								      item);
6057 6058
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
6059
			em->block_start = EXTENT_MAP_HOLE;
6060 6061
			goto insert;
		}
6062
		if (compress_type != BTRFS_COMPRESS_NONE) {
C
Chris Mason 已提交
6063
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6064
			em->compress_type = compress_type;
C
Chris Mason 已提交
6065
			em->block_start = bytenr;
6066
			em->block_len = em->orig_block_len;
C
Chris Mason 已提交
6067 6068 6069 6070
		} else {
			bytenr += btrfs_file_extent_offset(leaf, item);
			em->block_start = bytenr;
			em->block_len = em->len;
Y
Yan Zheng 已提交
6071 6072
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
C
Chris Mason 已提交
6073
		}
6074 6075
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6076
		unsigned long ptr;
6077
		char *map;
6078 6079 6080
		size_t size;
		size_t extent_offset;
		size_t copy_size;
6081

6082
		em->block_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
6083
		if (!page || create) {
6084
			em->start = extent_start;
Y
Yan Zheng 已提交
6085
			em->len = extent_end - extent_start;
6086 6087
			goto out;
		}
6088

Y
Yan Zheng 已提交
6089 6090
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
6091
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
6092 6093
				size - extent_offset);
		em->start = extent_start + extent_offset;
6094
		em->len = ALIGN(copy_size, root->sectorsize);
6095
		em->orig_block_len = em->len;
6096
		em->orig_start = em->start;
6097
		if (compress_type) {
C
Chris Mason 已提交
6098
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6099 6100
			em->compress_type = compress_type;
		}
6101
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
6102
		if (create == 0 && !PageUptodate(page)) {
6103 6104
			if (btrfs_file_extent_compression(leaf, item) !=
			    BTRFS_COMPRESS_NONE) {
C
Chris Mason 已提交
6105 6106 6107
				ret = uncompress_inline(path, inode, page,
							pg_offset,
							extent_offset, item);
6108
				BUG_ON(ret); /* -ENOMEM */
C
Chris Mason 已提交
6109 6110 6111 6112
			} else {
				map = kmap(page);
				read_extent_buffer(leaf, map + pg_offset, ptr,
						   copy_size);
6113 6114 6115 6116 6117
				if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
					memset(map + pg_offset + copy_size, 0,
					       PAGE_CACHE_SIZE - pg_offset -
					       copy_size);
				}
C
Chris Mason 已提交
6118 6119
				kunmap(page);
			}
6120 6121
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
6122
			BUG();
6123 6124 6125 6126
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
C
Chris Mason 已提交
6127

6128
				btrfs_release_path(path);
6129
				trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
6130

6131 6132
				if (IS_ERR(trans))
					return ERR_CAST(trans);
6133 6134
				goto again;
			}
C
Chris Mason 已提交
6135
			map = kmap(page);
6136
			write_extent_buffer(leaf, map + pg_offset, ptr,
6137
					    copy_size);
C
Chris Mason 已提交
6138
			kunmap(page);
6139
			btrfs_mark_buffer_dirty(leaf);
6140
		}
6141
		set_extent_uptodate(io_tree, em->start,
6142
				    extent_map_end(em) - 1, NULL, GFP_NOFS);
6143 6144
		goto insert;
	} else {
J
Julia Lawall 已提交
6145
		WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
6146 6147 6148
	}
not_found:
	em->start = start;
6149
	em->orig_start = start;
6150
	em->len = len;
6151
not_found_em:
6152
	em->block_start = EXTENT_MAP_HOLE;
Y
Yan Zheng 已提交
6153
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
6154
insert:
6155
	btrfs_release_path(path);
6156
	if (em->start > start || extent_map_end(em) <= start) {
6157 6158 6159 6160 6161
		btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]",
			(unsigned long long)em->start,
			(unsigned long long)em->len,
			(unsigned long long)start,
			(unsigned long long)len);
6162 6163 6164
		err = -EIO;
		goto out;
	}
6165 6166

	err = 0;
6167
	write_lock(&em_tree->lock);
J
Josef Bacik 已提交
6168
	ret = add_extent_mapping(em_tree, em, 0);
6169 6170 6171 6172
	/* it is possible that someone inserted the extent into the tree
	 * while we had the lock dropped.  It is also possible that
	 * an overlapping map exists in the tree
	 */
6173
	if (ret == -EEXIST) {
6174
		struct extent_map *existing;
6175 6176 6177

		ret = 0;

6178
		existing = lookup_extent_mapping(em_tree, start, len);
6179 6180 6181 6182 6183
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
6184 6185 6186 6187 6188
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
6189 6190
							   em, start,
							   root->sectorsize);
6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203
				free_extent_map(existing);
				if (err) {
					free_extent_map(em);
					em = NULL;
				}
			} else {
				err = -EIO;
				free_extent_map(em);
				em = NULL;
			}
		} else {
			free_extent_map(em);
			em = existing;
6204
			err = 0;
6205 6206
		}
	}
6207
	write_unlock(&em_tree->lock);
6208
out:
6209

6210 6211
	if (em)
		trace_btrfs_get_extent(root, em);
6212

6213 6214
	if (path)
		btrfs_free_path(path);
6215 6216
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
6217
		if (!err)
6218 6219 6220 6221 6222 6223
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
6224
	BUG_ON(!em); /* Error is always set */
6225 6226 6227
	return em;
}

6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244
struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
					   size_t pg_offset, u64 start, u64 len,
					   int create)
{
	struct extent_map *em;
	struct extent_map *hole_em = NULL;
	u64 range_start = start;
	u64 end;
	u64 found;
	u64 found_end;
	int err = 0;

	em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
	if (IS_ERR(em))
		return em;
	if (em) {
		/*
6245 6246 6247 6248
		 * if our em maps to
		 * -  a hole or
		 * -  a pre-alloc extent,
		 * there might actually be delalloc bytes behind it.
6249
		 */
6250 6251
		if (em->block_start != EXTENT_MAP_HOLE &&
		    !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292
			return em;
		else
			hole_em = em;
	}

	/* check to see if we've wrapped (len == -1 or similar) */
	end = start + len;
	if (end < start)
		end = (u64)-1;
	else
		end -= 1;

	em = NULL;

	/* ok, we didn't find anything, lets look for delalloc */
	found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
				 end, len, EXTENT_DELALLOC, 1);
	found_end = range_start + found;
	if (found_end < range_start)
		found_end = (u64)-1;

	/*
	 * we didn't find anything useful, return
	 * the original results from get_extent()
	 */
	if (range_start > end || found_end <= start) {
		em = hole_em;
		hole_em = NULL;
		goto out;
	}

	/* adjust the range_start to make sure it doesn't
	 * go backwards from the start they passed in
	 */
	range_start = max(start,range_start);
	found = found_end - range_start;

	if (found > 0) {
		u64 hole_start = start;
		u64 hole_len = len;

6293
		em = alloc_extent_map();
6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332
		if (!em) {
			err = -ENOMEM;
			goto out;
		}
		/*
		 * when btrfs_get_extent can't find anything it
		 * returns one huge hole
		 *
		 * make sure what it found really fits our range, and
		 * adjust to make sure it is based on the start from
		 * the caller
		 */
		if (hole_em) {
			u64 calc_end = extent_map_end(hole_em);

			if (calc_end <= start || (hole_em->start > end)) {
				free_extent_map(hole_em);
				hole_em = NULL;
			} else {
				hole_start = max(hole_em->start, start);
				hole_len = calc_end - hole_start;
			}
		}
		em->bdev = NULL;
		if (hole_em && range_start > hole_start) {
			/* our hole starts before our delalloc, so we
			 * have to return just the parts of the hole
			 * that go until  the delalloc starts
			 */
			em->len = min(hole_len,
				      range_start - hole_start);
			em->start = hole_start;
			em->orig_start = hole_start;
			/*
			 * don't adjust block start at all,
			 * it is fixed at EXTENT_MAP_HOLE
			 */
			em->block_start = hole_em->block_start;
			em->block_len = hole_len;
6333 6334
			if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354
		} else {
			em->start = range_start;
			em->len = found;
			em->orig_start = range_start;
			em->block_start = EXTENT_MAP_DELALLOC;
			em->block_len = found;
		}
	} else if (hole_em) {
		return hole_em;
	}
out:

	free_extent_map(hole_em);
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
	return em;
}

6355 6356 6357 6358 6359
static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
						  u64 start, u64 len)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
6360
	struct extent_map *em;
6361 6362 6363 6364
	struct btrfs_key ins;
	u64 alloc_hint;
	int ret;

6365
	trans = btrfs_join_transaction(root);
6366 6367
	if (IS_ERR(trans))
		return ERR_CAST(trans);
6368 6369 6370 6371 6372

	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

	alloc_hint = get_extent_allocation_hint(inode, start, len);
	ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
6373
				   alloc_hint, &ins, 1);
6374 6375 6376 6377 6378
	if (ret) {
		em = ERR_PTR(ret);
		goto out;
	}

6379
	em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
J
Josef Bacik 已提交
6380
			      ins.offset, ins.offset, ins.offset, 0);
6381 6382
	if (IS_ERR(em))
		goto out;
6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394

	ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
					   ins.offset, ins.offset, 0);
	if (ret) {
		btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
		em = ERR_PTR(ret);
	}
out:
	btrfs_end_transaction(trans, root);
	return em;
}

6395 6396 6397 6398 6399
/*
 * returns 1 when the nocow is safe, < 1 on error, 0 if the
 * block must be cow'd
 */
static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
6400 6401 6402
				      struct inode *inode, u64 offset, u64 *len,
				      u64 *orig_start, u64 *orig_block_len,
				      u64 *ram_bytes)
6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420
{
	struct btrfs_path *path;
	int ret;
	struct extent_buffer *leaf;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *fi;
	struct btrfs_key key;
	u64 disk_bytenr;
	u64 backref_offset;
	u64 extent_end;
	u64 num_bytes;
	int slot;
	int found_type;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

L
Li Zefan 已提交
6421
	ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437
				       offset, 0);
	if (ret < 0)
		goto out;

	slot = path->slots[0];
	if (ret == 1) {
		if (slot == 0) {
			/* can't find the item, must cow */
			ret = 0;
			goto out;
		}
		slot--;
	}
	ret = 0;
	leaf = path->nodes[0];
	btrfs_item_key_to_cpu(leaf, &key, slot);
L
Li Zefan 已提交
6438
	if (key.objectid != btrfs_ino(inode) ||
6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458
	    key.type != BTRFS_EXTENT_DATA_KEY) {
		/* not our file or wrong item type, must cow */
		goto out;
	}

	if (key.offset > offset) {
		/* Wrong offset, must cow */
		goto out;
	}

	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
	found_type = btrfs_file_extent_type(leaf, fi);
	if (found_type != BTRFS_FILE_EXTENT_REG &&
	    found_type != BTRFS_FILE_EXTENT_PREALLOC) {
		/* not a regular extent, must cow */
		goto out;
	}
	disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
	backref_offset = btrfs_file_extent_offset(leaf, fi);

6459 6460 6461 6462
	*orig_start = key.offset - backref_offset;
	*orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
	*ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);

6463
	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
6464
	if (extent_end < offset + *len) {
6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475
		/* extent doesn't include our full range, must cow */
		goto out;
	}

	if (btrfs_extent_readonly(root, disk_bytenr))
		goto out;

	/*
	 * look for other files referencing this extent, if we
	 * find any we must cow
	 */
L
Li Zefan 已提交
6476
	if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487
				  key.offset - backref_offset, disk_bytenr))
		goto out;

	/*
	 * adjust disk_bytenr and num_bytes to cover just the bytes
	 * in this extent we are about to write.  If there
	 * are any csums in that range we have to cow in order
	 * to keep the csums correct
	 */
	disk_bytenr += backref_offset;
	disk_bytenr += offset - key.offset;
6488
	num_bytes = min(offset + *len, extent_end) - offset;
6489 6490 6491 6492 6493 6494
	if (csum_exist_in_range(root, disk_bytenr, num_bytes))
				goto out;
	/*
	 * all of the above have passed, it is safe to overwrite this extent
	 * without cow
	 */
6495
	*len = num_bytes;
6496 6497 6498 6499 6500 6501
	ret = 1;
out:
	btrfs_free_path(path);
	return ret;
}

6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562
static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
			      struct extent_state **cached_state, int writing)
{
	struct btrfs_ordered_extent *ordered;
	int ret = 0;

	while (1) {
		lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
				 0, cached_state);
		/*
		 * We're concerned with the entire range that we're going to be
		 * doing DIO to, so we need to make sure theres no ordered
		 * extents in this range.
		 */
		ordered = btrfs_lookup_ordered_range(inode, lockstart,
						     lockend - lockstart + 1);

		/*
		 * We need to make sure there are no buffered pages in this
		 * range either, we could have raced between the invalidate in
		 * generic_file_direct_write and locking the extent.  The
		 * invalidate needs to happen so that reads after a write do not
		 * get stale data.
		 */
		if (!ordered && (!writing ||
		    !test_range_bit(&BTRFS_I(inode)->io_tree,
				    lockstart, lockend, EXTENT_UPTODATE, 0,
				    *cached_state)))
			break;

		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
				     cached_state, GFP_NOFS);

		if (ordered) {
			btrfs_start_ordered_extent(inode, ordered, 1);
			btrfs_put_ordered_extent(ordered);
		} else {
			/* Screw you mmap */
			ret = filemap_write_and_wait_range(inode->i_mapping,
							   lockstart,
							   lockend);
			if (ret)
				break;

			/*
			 * If we found a page that couldn't be invalidated just
			 * fall back to buffered.
			 */
			ret = invalidate_inode_pages2_range(inode->i_mapping,
					lockstart >> PAGE_CACHE_SHIFT,
					lockend >> PAGE_CACHE_SHIFT);
			if (ret)
				break;
		}

		cond_resched();
	}

	return ret;
}

6563 6564 6565
static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
					   u64 len, u64 orig_start,
					   u64 block_start, u64 block_len,
J
Josef Bacik 已提交
6566 6567
					   u64 orig_block_len, u64 ram_bytes,
					   int type)
6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580
{
	struct extent_map_tree *em_tree;
	struct extent_map *em;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

	em_tree = &BTRFS_I(inode)->extent_tree;
	em = alloc_extent_map();
	if (!em)
		return ERR_PTR(-ENOMEM);

	em->start = start;
	em->orig_start = orig_start;
6581 6582
	em->mod_start = start;
	em->mod_len = len;
6583 6584 6585 6586
	em->len = len;
	em->block_len = block_len;
	em->block_start = block_start;
	em->bdev = root->fs_info->fs_devices->latest_bdev;
6587
	em->orig_block_len = orig_block_len;
J
Josef Bacik 已提交
6588
	em->ram_bytes = ram_bytes;
6589
	em->generation = -1;
6590 6591
	set_bit(EXTENT_FLAG_PINNED, &em->flags);
	if (type == BTRFS_ORDERED_PREALLOC)
6592
		set_bit(EXTENT_FLAG_FILLING, &em->flags);
6593 6594 6595 6596 6597

	do {
		btrfs_drop_extent_cache(inode, em->start,
				em->start + em->len - 1, 0);
		write_lock(&em_tree->lock);
J
Josef Bacik 已提交
6598
		ret = add_extent_mapping(em_tree, em, 1);
6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610
		write_unlock(&em_tree->lock);
	} while (ret == -EEXIST);

	if (ret) {
		free_extent_map(em);
		return ERR_PTR(ret);
	}

	return em;
}


6611 6612 6613 6614 6615
static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
				   struct buffer_head *bh_result, int create)
{
	struct extent_map *em;
	struct btrfs_root *root = BTRFS_I(inode)->root;
6616
	struct extent_state *cached_state = NULL;
6617
	u64 start = iblock << inode->i_blkbits;
6618
	u64 lockstart, lockend;
6619
	u64 len = bh_result->b_size;
6620
	struct btrfs_trans_handle *trans;
6621
	int unlock_bits = EXTENT_LOCKED;
6622
	int ret = 0;
6623

6624
	if (create)
6625
		unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY;
6626
	else
6627
		len = min_t(u64, len, root->sectorsize);
6628

6629 6630 6631
	lockstart = start;
	lockend = start + len - 1;

6632 6633 6634 6635 6636 6637 6638
	/*
	 * If this errors out it's because we couldn't invalidate pagecache for
	 * this range and we need to fallback to buffered.
	 */
	if (lock_extent_direct(inode, lockstart, lockend, &cached_state, create))
		return -ENOTBLK;

6639
	em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
6640 6641 6642 6643
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661

	/*
	 * Ok for INLINE and COMPRESSED extents we need to fallback on buffered
	 * io.  INLINE is special, and we could probably kludge it in here, but
	 * it's still buffered so for safety lets just fall back to the generic
	 * buffered path.
	 *
	 * For COMPRESSED we _have_ to read the entire extent in so we can
	 * decompress it, so there will be buffering required no matter what we
	 * do, so go ahead and fallback to buffered.
	 *
	 * We return -ENOTBLK because thats what makes DIO go ahead and go back
	 * to buffered IO.  Don't blame me, this is the price we pay for using
	 * the generic code.
	 */
	if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||
	    em->block_start == EXTENT_MAP_INLINE) {
		free_extent_map(em);
6662 6663
		ret = -ENOTBLK;
		goto unlock_err;
6664 6665 6666 6667 6668 6669
	}

	/* Just a good old fashioned hole, return */
	if (!create && (em->block_start == EXTENT_MAP_HOLE ||
			test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
		free_extent_map(em);
6670
		goto unlock_err;
6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681
	}

	/*
	 * We don't allocate a new extent in the following cases
	 *
	 * 1) The inode is marked as NODATACOW.  In this case we'll just use the
	 * existing extent.
	 * 2) The extent is marked as PREALLOC.  We're good to go here and can
	 * just use the extent.
	 *
	 */
6682
	if (!create) {
6683 6684 6685
		len = min(len, em->len - (start - em->start));
		lockstart = start + len;
		goto unlock;
6686
	}
6687 6688 6689 6690 6691 6692

	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
	    ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
	     em->block_start != EXTENT_MAP_HOLE)) {
		int type;
		int ret;
6693
		u64 block_start, orig_start, orig_block_len, ram_bytes;
6694 6695 6696 6697 6698

		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
			type = BTRFS_ORDERED_PREALLOC;
		else
			type = BTRFS_ORDERED_NOCOW;
6699
		len = min(len, em->len - (start - em->start));
6700
		block_start = em->block_start + (start - em->start);
6701 6702 6703 6704 6705 6706

		/*
		 * we're not going to log anything, but we do need
		 * to make sure the current transaction stays open
		 * while we look for nocow cross refs
		 */
6707
		trans = btrfs_join_transaction(root);
6708
		if (IS_ERR(trans))
6709 6710
			goto must_cow;

6711 6712
		if (can_nocow_odirect(trans, inode, start, &len, &orig_start,
				      &orig_block_len, &ram_bytes) == 1) {
6713 6714 6715 6716
			if (type == BTRFS_ORDERED_PREALLOC) {
				free_extent_map(em);
				em = create_pinned_em(inode, start, len,
						       orig_start,
6717
						       block_start, len,
J
Josef Bacik 已提交
6718 6719
						       orig_block_len,
						       ram_bytes, type);
6720 6721 6722 6723 6724 6725
				if (IS_ERR(em)) {
					btrfs_end_transaction(trans, root);
					goto unlock_err;
				}
			}

6726 6727 6728 6729 6730
			ret = btrfs_add_ordered_extent_dio(inode, start,
					   block_start, len, len, type);
			btrfs_end_transaction(trans, root);
			if (ret) {
				free_extent_map(em);
6731
				goto unlock_err;
6732 6733
			}
			goto unlock;
6734
		}
6735
		btrfs_end_transaction(trans, root);
6736
	}
6737 6738 6739 6740 6741 6742
must_cow:
	/*
	 * this will cow the extent, reset the len in case we changed
	 * it above
	 */
	len = bh_result->b_size;
6743 6744
	free_extent_map(em);
	em = btrfs_new_extent_direct(inode, start, len);
6745 6746 6747 6748
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
6749 6750
	len = min(len, em->len - (start - em->start));
unlock:
6751 6752
	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
		inode->i_blkbits;
6753
	bh_result->b_size = len;
6754 6755
	bh_result->b_bdev = em->bdev;
	set_buffer_mapped(bh_result);
6756 6757 6758 6759 6760 6761 6762 6763 6764 6765
	if (create) {
		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
			set_buffer_new(bh_result);

		/*
		 * Need to update the i_size under the extent lock so buffered
		 * readers will get the updated i_size when we unlock.
		 */
		if (start + len > i_size_read(inode))
			i_size_write(inode, start + len);
6766

6767 6768 6769 6770
		spin_lock(&BTRFS_I(inode)->lock);
		BTRFS_I(inode)->outstanding_extents++;
		spin_unlock(&BTRFS_I(inode)->lock);

6771 6772 6773 6774
		ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
				     lockstart + len - 1, EXTENT_DELALLOC, NULL,
				     &cached_state, GFP_NOFS);
		BUG_ON(ret);
6775
	}
6776

6777 6778 6779 6780 6781
	/*
	 * In the case of write we need to clear and unlock the entire range,
	 * in the case of read we need to unlock only the end area that we
	 * aren't using if there is any left over space.
	 */
L
Liu Bo 已提交
6782
	if (lockstart < lockend) {
6783 6784 6785
		clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
				 lockend, unlock_bits, 1, 0,
				 &cached_state, GFP_NOFS);
L
Liu Bo 已提交
6786
	} else {
6787
		free_extent_state(cached_state);
L
Liu Bo 已提交
6788
	}
6789

6790 6791 6792
	free_extent_map(em);

	return 0;
6793 6794 6795 6796 6797

unlock_err:
	clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
			 unlock_bits, 1, 0, &cached_state, GFP_NOFS);
	return ret;
6798 6799 6800 6801 6802 6803 6804 6805
}

struct btrfs_dio_private {
	struct inode *inode;
	u64 logical_offset;
	u64 disk_bytenr;
	u64 bytes;
	void *private;
M
Miao Xie 已提交
6806 6807 6808 6809 6810 6811 6812

	/* number of bios pending for this dio */
	atomic_t pending_bios;

	/* IO errors */
	int errors;

6813
	/* orig_bio is our btrfs_io_bio */
M
Miao Xie 已提交
6814
	struct bio *orig_bio;
6815 6816 6817

	/* dio_bio came from fs/direct-io.c */
	struct bio *dio_bio;
6818 6819 6820 6821
};

static void btrfs_endio_direct_read(struct bio *bio, int err)
{
M
Miao Xie 已提交
6822
	struct btrfs_dio_private *dip = bio->bi_private;
6823 6824 6825
	struct bio_vec *bvec_end = bio->bi_io_vec + bio->bi_vcnt - 1;
	struct bio_vec *bvec = bio->bi_io_vec;
	struct inode *inode = dip->inode;
6826
	struct btrfs_root *root = BTRFS_I(inode)->root;
6827
	struct bio *dio_bio;
6828 6829 6830 6831 6832 6833 6834 6835
	u64 start;

	start = dip->logical_offset;
	do {
		if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
			struct page *page = bvec->bv_page;
			char *kaddr;
			u32 csum = ~(u32)0;
6836
			u64 private = ~(u32)0;
6837 6838
			unsigned long flags;

6839 6840 6841
			if (get_state_private(&BTRFS_I(inode)->io_tree,
					      start, &private))
				goto failed;
6842
			local_irq_save(flags);
6843
			kaddr = kmap_atomic(page);
6844
			csum = btrfs_csum_data(kaddr + bvec->bv_offset,
6845 6846
					       csum, bvec->bv_len);
			btrfs_csum_final(csum, (char *)&csum);
6847
			kunmap_atomic(kaddr);
6848 6849 6850
			local_irq_restore(flags);

			flush_dcache_page(bvec->bv_page);
6851 6852
			if (csum != private) {
failed:
6853 6854 6855 6856
				btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u private %u",
					(unsigned long long)btrfs_ino(inode),
					(unsigned long long)start,
					csum, (unsigned)private);
6857 6858 6859 6860 6861 6862 6863 6864 6865
				err = -EIO;
			}
		}

		start += bvec->bv_len;
		bvec++;
	} while (bvec <= bvec_end);

	unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
6866
		      dip->logical_offset + dip->bytes - 1);
6867
	dio_bio = dip->dio_bio;
6868 6869

	kfree(dip);
6870 6871 6872

	/* If we had a csum failure make sure to clear the uptodate flag */
	if (err)
6873 6874 6875
		clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
	dio_end_io(dio_bio, err);
	bio_put(bio);
6876 6877 6878 6879 6880 6881 6882 6883
}

static void btrfs_endio_direct_write(struct bio *bio, int err)
{
	struct btrfs_dio_private *dip = bio->bi_private;
	struct inode *inode = dip->inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_ordered_extent *ordered = NULL;
6884 6885
	u64 ordered_offset = dip->logical_offset;
	u64 ordered_bytes = dip->bytes;
6886
	struct bio *dio_bio;
6887 6888 6889 6890
	int ret;

	if (err)
		goto out_done;
6891 6892 6893
again:
	ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
						   &ordered_offset,
6894
						   ordered_bytes, !err);
6895
	if (!ret)
6896
		goto out_test;
6897

6898 6899 6900 6901
	ordered->work.func = finish_ordered_fn;
	ordered->work.flags = 0;
	btrfs_queue_worker(&root->fs_info->endio_write_workers,
			   &ordered->work);
6902 6903 6904 6905 6906 6907 6908 6909
out_test:
	/*
	 * our bio might span multiple ordered extents.  If we haven't
	 * completed the accounting for the whole dio, go back and try again
	 */
	if (ordered_offset < dip->logical_offset + dip->bytes) {
		ordered_bytes = dip->logical_offset + dip->bytes -
			ordered_offset;
6910
		ordered = NULL;
6911 6912
		goto again;
	}
6913
out_done:
6914
	dio_bio = dip->dio_bio;
6915 6916

	kfree(dip);
6917 6918 6919

	/* If we had an error make sure to clear the uptodate flag */
	if (err)
6920 6921 6922
		clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
	dio_end_io(dio_bio, err);
	bio_put(bio);
6923 6924
}

6925 6926 6927 6928 6929 6930 6931
static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
				    unsigned long bio_flags, u64 offset)
{
	int ret;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	ret = btrfs_csum_one_bio(root, inode, bio, offset, 1);
6932
	BUG_ON(ret); /* -ENOMEM */
6933 6934 6935
	return 0;
}

M
Miao Xie 已提交
6936 6937 6938 6939 6940
static void btrfs_end_dio_bio(struct bio *bio, int err)
{
	struct btrfs_dio_private *dip = bio->bi_private;

	if (err) {
L
Li Zefan 已提交
6941
		printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
J
Jan Beulich 已提交
6942
		      "sector %#Lx len %u err no %d\n",
L
Li Zefan 已提交
6943
		      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
J
Jan Beulich 已提交
6944
		      (unsigned long long)bio->bi_sector, bio->bi_size, err);
M
Miao Xie 已提交
6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957
		dip->errors = 1;

		/*
		 * before atomic variable goto zero, we must make sure
		 * dip->errors is perceived to be set.
		 */
		smp_mb__before_atomic_dec();
	}

	/* if there are more bios still pending for this dio, just exit */
	if (!atomic_dec_and_test(&dip->pending_bios))
		goto out;

6958
	if (dip->errors) {
M
Miao Xie 已提交
6959
		bio_io_error(dip->orig_bio);
6960 6961
	} else {
		set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags);
M
Miao Xie 已提交
6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976
		bio_endio(dip->orig_bio, 0);
	}
out:
	bio_put(bio);
}

static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
				       u64 first_sector, gfp_t gfp_flags)
{
	int nr_vecs = bio_get_nr_vecs(bdev);
	return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags);
}

static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
					 int rw, u64 file_offset, int skip_sum,
6977
					 int async_submit)
M
Miao Xie 已提交
6978 6979 6980 6981 6982
{
	int write = rw & REQ_WRITE;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

6983 6984 6985
	if (async_submit)
		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);

M
Miao Xie 已提交
6986
	bio_get(bio);
6987 6988 6989 6990 6991 6992

	if (!write) {
		ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
		if (ret)
			goto err;
	}
M
Miao Xie 已提交
6993

6994 6995 6996 6997
	if (skip_sum)
		goto map;

	if (write && async_submit) {
M
Miao Xie 已提交
6998 6999 7000 7001 7002 7003
		ret = btrfs_wq_submit_bio(root->fs_info,
				   inode, rw, bio, 0, 0,
				   file_offset,
				   __btrfs_submit_bio_start_direct_io,
				   __btrfs_submit_bio_done);
		goto err;
7004 7005 7006 7007 7008 7009 7010 7011
	} else if (write) {
		/*
		 * If we aren't doing async submit, calculate the csum of the
		 * bio now.
		 */
		ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
		if (ret)
			goto err;
7012
	} else if (!skip_sum) {
7013
		ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
7014 7015 7016
		if (ret)
			goto err;
	}
M
Miao Xie 已提交
7017

7018 7019
map:
	ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
M
Miao Xie 已提交
7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038
err:
	bio_put(bio);
	return ret;
}

static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
				    int skip_sum)
{
	struct inode *inode = dip->inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct bio *bio;
	struct bio *orig_bio = dip->orig_bio;
	struct bio_vec *bvec = orig_bio->bi_io_vec;
	u64 start_sector = orig_bio->bi_sector;
	u64 file_offset = dip->logical_offset;
	u64 submit_len = 0;
	u64 map_length;
	int nr_pages = 0;
	int ret = 0;
7039
	int async_submit = 0;
M
Miao Xie 已提交
7040 7041

	map_length = orig_bio->bi_size;
D
David Woodhouse 已提交
7042
	ret = btrfs_map_block(root->fs_info, rw, start_sector << 9,
M
Miao Xie 已提交
7043 7044
			      &map_length, NULL, 0);
	if (ret) {
7045
		bio_put(orig_bio);
M
Miao Xie 已提交
7046 7047
		return -EIO;
	}
7048 7049 7050 7051 7052
	if (map_length >= orig_bio->bi_size) {
		bio = orig_bio;
		goto submit;
	}

D
David Woodhouse 已提交
7053 7054 7055 7056 7057 7058 7059
	/* async crcs make it difficult to collect full stripe writes. */
	if (btrfs_get_alloc_profile(root, 1) &
	    (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6))
		async_submit = 0;
	else
		async_submit = 1;

7060 7061 7062 7063 7064 7065 7066
	bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
	if (!bio)
		return -ENOMEM;
	bio->bi_private = dip;
	bio->bi_end_io = btrfs_end_dio_bio;
	atomic_inc(&dip->pending_bios);

M
Miao Xie 已提交
7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079
	while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
		if (unlikely(map_length < submit_len + bvec->bv_len ||
		    bio_add_page(bio, bvec->bv_page, bvec->bv_len,
				 bvec->bv_offset) < bvec->bv_len)) {
			/*
			 * inc the count before we submit the bio so
			 * we know the end IO handler won't happen before
			 * we inc the count. Otherwise, the dip might get freed
			 * before we're done setting it up
			 */
			atomic_inc(&dip->pending_bios);
			ret = __btrfs_submit_dio_bio(bio, inode, rw,
						     file_offset, skip_sum,
7080
						     async_submit);
M
Miao Xie 已提交
7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100
			if (ret) {
				bio_put(bio);
				atomic_dec(&dip->pending_bios);
				goto out_err;
			}

			start_sector += submit_len >> 9;
			file_offset += submit_len;

			submit_len = 0;
			nr_pages = 0;

			bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
						  start_sector, GFP_NOFS);
			if (!bio)
				goto out_err;
			bio->bi_private = dip;
			bio->bi_end_io = btrfs_end_dio_bio;

			map_length = orig_bio->bi_size;
D
David Woodhouse 已提交
7101
			ret = btrfs_map_block(root->fs_info, rw,
7102
					      start_sector << 9,
M
Miao Xie 已提交
7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114
					      &map_length, NULL, 0);
			if (ret) {
				bio_put(bio);
				goto out_err;
			}
		} else {
			submit_len += bvec->bv_len;
			nr_pages ++;
			bvec++;
		}
	}

7115
submit:
M
Miao Xie 已提交
7116
	ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
7117
				     async_submit);
M
Miao Xie 已提交
7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135
	if (!ret)
		return 0;

	bio_put(bio);
out_err:
	dip->errors = 1;
	/*
	 * before atomic variable goto zero, we must
	 * make sure dip->errors is perceived to be set.
	 */
	smp_mb__before_atomic_dec();
	if (atomic_dec_and_test(&dip->pending_bios))
		bio_io_error(dip->orig_bio);

	/* bio_end_io() will handle error, so we needn't return it */
	return 0;
}

7136 7137
static void btrfs_submit_direct(int rw, struct bio *dio_bio,
				struct inode *inode, loff_t file_offset)
7138 7139 7140
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_dio_private *dip;
7141 7142
	struct bio_vec *bvec = dio_bio->bi_io_vec;
	struct bio *io_bio;
7143
	int skip_sum;
7144
	int write = rw & REQ_WRITE;
7145 7146 7147 7148
	int ret = 0;

	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;

7149 7150 7151 7152 7153 7154 7155
	io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);

	if (!io_bio) {
		ret = -ENOMEM;
		goto free_ordered;
	}

7156 7157 7158
	dip = kmalloc(sizeof(*dip), GFP_NOFS);
	if (!dip) {
		ret = -ENOMEM;
7159
		goto free_io_bio;
7160 7161
	}

7162 7163
	dip->private = dio_bio->bi_private;
	io_bio->bi_private = dio_bio->bi_private;
7164 7165 7166 7167 7168 7169 7170
	dip->inode = inode;
	dip->logical_offset = file_offset;

	dip->bytes = 0;
	do {
		dip->bytes += bvec->bv_len;
		bvec++;
7171
	} while (bvec <= (dio_bio->bi_io_vec + dio_bio->bi_vcnt - 1));
7172

7173 7174
	dip->disk_bytenr = (u64)dio_bio->bi_sector << 9;
	io_bio->bi_private = dip;
M
Miao Xie 已提交
7175
	dip->errors = 0;
7176 7177
	dip->orig_bio = io_bio;
	dip->dio_bio = dio_bio;
M
Miao Xie 已提交
7178
	atomic_set(&dip->pending_bios, 0);
7179 7180

	if (write)
7181
		io_bio->bi_end_io = btrfs_endio_direct_write;
7182
	else
7183
		io_bio->bi_end_io = btrfs_endio_direct_read;
7184

M
Miao Xie 已提交
7185 7186
	ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
	if (!ret)
7187
		return;
7188 7189 7190 7191

free_io_bio:
	bio_put(io_bio);

7192 7193 7194 7195 7196 7197 7198
free_ordered:
	/*
	 * If this is a write, we need to clean up the reserved space and kill
	 * the ordered extent.
	 */
	if (write) {
		struct btrfs_ordered_extent *ordered;
7199
		ordered = btrfs_lookup_ordered_extent(inode, file_offset);
7200 7201 7202 7203 7204 7205 7206
		if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
			btrfs_free_reserved_extent(root, ordered->start,
						   ordered->disk_len);
		btrfs_put_ordered_extent(ordered);
		btrfs_put_ordered_extent(ordered);
	}
7207
	bio_endio(dio_bio, ret);
7208 7209
}

C
Chris Mason 已提交
7210 7211 7212 7213 7214
static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
	int seg;
7215
	int i;
C
Chris Mason 已提交
7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229
	size_t size;
	unsigned long addr;
	unsigned blocksize_mask = root->sectorsize - 1;
	ssize_t retval = -EINVAL;
	loff_t end = offset;

	if (offset & blocksize_mask)
		goto out;

	/* Check the memory alignment.  Blocks cannot straddle pages */
	for (seg = 0; seg < nr_segs; seg++) {
		addr = (unsigned long)iov[seg].iov_base;
		size = iov[seg].iov_len;
		end += size;
7230
		if ((addr & blocksize_mask) || (size & blocksize_mask))
C
Chris Mason 已提交
7231
			goto out;
7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245

		/* If this is a write we don't need to check anymore */
		if (rw & WRITE)
			continue;

		/*
		 * Check to make sure we don't have duplicate iov_base's in this
		 * iovec, if so return EINVAL, otherwise we'll get csum errors
		 * when reading back.
		 */
		for (i = seg + 1; i < nr_segs; i++) {
			if (iov[seg].iov_base == iov[i].iov_base)
				goto out;
		}
C
Chris Mason 已提交
7246 7247 7248 7249 7250
	}
	retval = 0;
out:
	return retval;
}
7251

7252 7253 7254 7255
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
7256 7257
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
7258
	size_t count = 0;
7259
	int flags = 0;
M
Miao Xie 已提交
7260 7261
	bool wakeup = true;
	bool relock = false;
7262
	ssize_t ret;
7263

C
Chris Mason 已提交
7264
	if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
7265
			    offset, nr_segs))
C
Chris Mason 已提交
7266
		return 0;
7267

M
Miao Xie 已提交
7268 7269 7270
	atomic_inc(&inode->i_dio_count);
	smp_mb__after_atomic_inc();

7271 7272
	if (rw & WRITE) {
		count = iov_length(iov, nr_segs);
M
Miao Xie 已提交
7273 7274 7275 7276 7277 7278 7279 7280 7281
		/*
		 * If the write DIO is beyond the EOF, we need update
		 * the isize, but it is protected by i_mutex. So we can
		 * not unlock the i_mutex at this case.
		 */
		if (offset + count <= inode->i_size) {
			mutex_unlock(&inode->i_mutex);
			relock = true;
		}
7282 7283
		ret = btrfs_delalloc_reserve_space(inode, count);
		if (ret)
M
Miao Xie 已提交
7284 7285 7286 7287 7288 7289
			goto out;
	} else if (unlikely(test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
				     &BTRFS_I(inode)->runtime_flags))) {
		inode_dio_done(inode);
		flags = DIO_LOCKING | DIO_SKIP_HOLES;
		wakeup = false;
7290 7291 7292 7293 7294
	}

	ret = __blockdev_direct_IO(rw, iocb, inode,
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
			iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
7295
			btrfs_submit_direct, flags);
7296 7297 7298
	if (rw & WRITE) {
		if (ret < 0 && ret != -EIOCBQUEUED)
			btrfs_delalloc_release_space(inode, count);
7299
		else if (ret >= 0 && (size_t)ret < count)
7300 7301
			btrfs_delalloc_release_space(inode,
						     count - (size_t)ret);
7302 7303
		else
			btrfs_delalloc_release_metadata(inode, 0);
7304
	}
M
Miao Xie 已提交
7305
out:
7306 7307
	if (wakeup)
		inode_dio_done(inode);
M
Miao Xie 已提交
7308 7309
	if (relock)
		mutex_lock(&inode->i_mutex);
7310 7311

	return ret;
7312 7313
}

T
Tsutomu Itoh 已提交
7314 7315
#define BTRFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC)

Y
Yehuda Sadeh 已提交
7316 7317 7318
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
T
Tsutomu Itoh 已提交
7319 7320 7321 7322 7323 7324
	int	ret;

	ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
	if (ret)
		return ret;

7325
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
Y
Yehuda Sadeh 已提交
7326 7327
}

7328
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
7329
{
7330 7331
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
7332
	return extent_read_full_page(tree, page, btrfs_get_extent, 0);
C
Chris Mason 已提交
7333
}
7334

7335
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
7336
{
7337
	struct extent_io_tree *tree;
7338 7339 7340 7341 7342 7343 7344


	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
7345
	tree = &BTRFS_I(page->mapping->host)->io_tree;
7346
	return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
C
Chris Mason 已提交
7347 7348
}

7349 7350
static int btrfs_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
C
Chris Mason 已提交
7351
{
7352
	struct extent_io_tree *tree;
7353

7354
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
7355 7356 7357
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
7358 7359 7360 7361
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
7362 7363
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
7364 7365 7366
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
7367
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
C
Chris Mason 已提交
7368
{
7369 7370
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
7371
	int ret;
7372

7373 7374
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
7375
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
7376 7377 7378 7379
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
7380
	}
7381
	return ret;
C
Chris Mason 已提交
7382 7383
}

7384 7385
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
7386 7387
	if (PageWriteback(page) || PageDirty(page))
		return 0;
7388
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
7389 7390
}

7391
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
7392
{
7393
	struct inode *inode = page->mapping->host;
7394
	struct extent_io_tree *tree;
7395
	struct btrfs_ordered_extent *ordered;
7396
	struct extent_state *cached_state = NULL;
7397 7398
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
7399

7400 7401 7402 7403 7404 7405 7406
	/*
	 * we have the page locked, so new writeback can't start,
	 * and the dirty bit won't be cleared while we are here.
	 *
	 * Wait for IO on this page so that we can safely clear
	 * the PagePrivate2 bit and do ordered accounting
	 */
7407
	wait_on_page_writeback(page);
7408

7409
	tree = &BTRFS_I(inode)->io_tree;
7410 7411 7412 7413
	if (offset) {
		btrfs_releasepage(page, GFP_NOFS);
		return;
	}
7414
	lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
M
Miao Xie 已提交
7415
	ordered = btrfs_lookup_ordered_extent(inode, page_offset(page));
7416
	if (ordered) {
7417 7418 7419 7420
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
7421 7422
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
7423 7424
				 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
				 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
7425 7426 7427 7428
		/*
		 * whoever cleared the private bit is responsible
		 * for the finish_ordered_io
		 */
7429 7430 7431 7432
		if (TestClearPagePrivate2(page) &&
		    btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
						   PAGE_CACHE_SIZE, 1)) {
			btrfs_finish_ordered_io(ordered);
7433
		}
7434
		btrfs_put_ordered_extent(ordered);
7435
		cached_state = NULL;
7436
		lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
7437 7438
	}
	clear_extent_bit(tree, page_start, page_end,
7439
		 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
7440 7441
		 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
		 &cached_state, GFP_NOFS);
7442 7443
	__btrfs_releasepage(page, GFP_NOFS);

C
Chris Mason 已提交
7444
	ClearPageChecked(page);
7445 7446 7447 7448 7449
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
7450 7451
}

C
Chris Mason 已提交
7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466
/*
 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
 * called from a page fault handler when a page is first dirtied. Hence we must
 * be careful to check for EOF conditions here. We set the page up correctly
 * for a written page which means we get ENOSPC checking when writing into
 * holes and correct delalloc and unwritten extent mapping on filesystems that
 * support these features.
 *
 * We are not allowed to take the i_mutex here so we have to play games to
 * protect against truncate races as the page could now be beyond EOF.  Because
 * vmtruncate() writes the inode size before removing pages, once we have the
 * page lock we can determine safely if the page is beyond EOF. If it is not
 * beyond EOF, then the page is guaranteed safe against truncation until we
 * unlock the page.
 */
7467
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
C
Chris Mason 已提交
7468
{
7469
	struct page *page = vmf->page;
A
Al Viro 已提交
7470
	struct inode *inode = file_inode(vma->vm_file);
7471
	struct btrfs_root *root = BTRFS_I(inode)->root;
7472 7473
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
7474
	struct extent_state *cached_state = NULL;
7475 7476
	char *kaddr;
	unsigned long zero_start;
C
Chris Mason 已提交
7477
	loff_t size;
7478
	int ret;
7479
	int reserved = 0;
7480
	u64 page_start;
7481
	u64 page_end;
C
Chris Mason 已提交
7482

7483
	sb_start_pagefault(inode->i_sb);
7484
	ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
7485
	if (!ret) {
7486
		ret = file_update_time(vma->vm_file);
7487 7488
		reserved = 1;
	}
7489 7490 7491 7492 7493
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
7494 7495 7496
		if (reserved)
			goto out;
		goto out_noreserve;
7497
	}
7498

7499
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
7500
again:
C
Chris Mason 已提交
7501 7502
	lock_page(page);
	size = i_size_read(inode);
7503 7504
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
7505

C
Chris Mason 已提交
7506
	if ((page->mapping != inode->i_mapping) ||
7507
	    (page_start >= size)) {
C
Chris Mason 已提交
7508 7509 7510
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
7511 7512
	wait_on_page_writeback(page);

7513
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
7514 7515
	set_page_extent_mapped(page);

7516 7517 7518 7519
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
7520 7521
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
7522 7523
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
7524
		unlock_page(page);
7525
		btrfs_start_ordered_extent(inode, ordered, 1);
7526 7527 7528 7529
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

J
Josef Bacik 已提交
7530 7531 7532 7533 7534 7535 7536
	/*
	 * XXX - page_mkwrite gets called every time the page is dirtied, even
	 * if it was already dirty, so for space accounting reasons we need to
	 * clear any delalloc bits for the range we are fixing to save.  There
	 * is probably a better way to do this, but for now keep consistent with
	 * prepare_pages in the normal write path.
	 */
7537
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
7538 7539
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
7540
			  0, 0, &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
7541

7542 7543
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
J
Josef Bacik 已提交
7544
	if (ret) {
7545 7546
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
7547 7548 7549
		ret = VM_FAULT_SIGBUS;
		goto out_unlock;
	}
7550
	ret = 0;
C
Chris Mason 已提交
7551 7552

	/* page is wholly or partially inside EOF */
7553
	if (page_start + PAGE_CACHE_SIZE > size)
7554
		zero_start = size & ~PAGE_CACHE_MASK;
C
Chris Mason 已提交
7555
	else
7556
		zero_start = PAGE_CACHE_SIZE;
C
Chris Mason 已提交
7557

7558 7559 7560 7561 7562 7563
	if (zero_start != PAGE_CACHE_SIZE) {
		kaddr = kmap(page);
		memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
		flush_dcache_page(page);
		kunmap(page);
	}
7564
	ClearPageChecked(page);
7565
	set_page_dirty(page);
7566
	SetPageUptodate(page);
7567

7568 7569
	BTRFS_I(inode)->last_trans = root->fs_info->generation;
	BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
7570
	BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
7571

7572
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
7573 7574

out_unlock:
7575 7576
	if (!ret) {
		sb_end_pagefault(inode->i_sb);
7577
		return VM_FAULT_LOCKED;
7578
	}
C
Chris Mason 已提交
7579
	unlock_page(page);
7580
out:
7581
	btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
7582
out_noreserve:
7583
	sb_end_pagefault(inode->i_sb);
C
Chris Mason 已提交
7584 7585 7586
	return ret;
}

7587
static int btrfs_truncate(struct inode *inode)
C
Chris Mason 已提交
7588 7589
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
7590
	struct btrfs_block_rsv *rsv;
7591
	int ret = 0;
7592
	int err = 0;
C
Chris Mason 已提交
7593
	struct btrfs_trans_handle *trans;
7594
	u64 mask = root->sectorsize - 1;
7595
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
7596

C
Chris Mason 已提交
7597
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
7598
	btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
C
Chris Mason 已提交
7599

7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635
	/*
	 * Yes ladies and gentelment, this is indeed ugly.  The fact is we have
	 * 3 things going on here
	 *
	 * 1) We need to reserve space for our orphan item and the space to
	 * delete our orphan item.  Lord knows we don't want to have a dangling
	 * orphan item because we didn't reserve space to remove it.
	 *
	 * 2) We need to reserve space to update our inode.
	 *
	 * 3) We need to have something to cache all the space that is going to
	 * be free'd up by the truncate operation, but also have some slack
	 * space reserved in case it uses space during the truncate (thank you
	 * very much snapshotting).
	 *
	 * And we need these to all be seperate.  The fact is we can use alot of
	 * space doing the truncate, and we have no earthly idea how much space
	 * we will use, so we need the truncate reservation to be seperate so it
	 * doesn't end up using space reserved for updating the inode or
	 * removing the orphan item.  We also need to be able to stop the
	 * transaction and start a new one, which means we need to be able to
	 * update the inode several times, and we have no idea of knowing how
	 * many times that will be, so we can't just reserve 1 item for the
	 * entirety of the opration, so that has to be done seperately as well.
	 * Then there is the orphan item, which does indeed need to be held on
	 * to for the whole operation, and we need nobody to touch this reserved
	 * space except the orphan code.
	 *
	 * So that leaves us with
	 *
	 * 1) root->orphan_block_rsv - for the orphan deletion.
	 * 2) rsv - for the truncate reservation, which we will steal from the
	 * transaction reservation.
	 * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
	 * updating the inode.
	 */
7636
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
7637 7638
	if (!rsv)
		return -ENOMEM;
J
Josef Bacik 已提交
7639
	rsv->size = min_size;
7640
	rsv->failfast = 1;
7641

7642
	/*
7643
	 * 1 for the truncate slack space
7644 7645
	 * 1 for updating the inode.
	 */
7646
	trans = btrfs_start_transaction(root, 2);
7647 7648 7649 7650
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out;
	}
7651

7652 7653 7654
	/* Migrate the slack space for the truncate to our reserve */
	ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
				      min_size);
7655
	BUG_ON(ret);
7656

7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673
	/*
	 * setattr is responsible for setting the ordered_data_close flag,
	 * but that is only tested during the last file release.  That
	 * could happen well after the next commit, leaving a great big
	 * window where new writes may get lost if someone chooses to write
	 * to this file after truncating to zero
	 *
	 * The inode doesn't have any dirty data here, and so if we commit
	 * this is a noop.  If someone immediately starts writing to the inode
	 * it is very likely we'll catch some of their writes in this
	 * transaction, and the commit will find this file on the ordered
	 * data list with good things to send down.
	 *
	 * This is a best effort solution, there is still a window where
	 * using truncate to replace the contents of the file will
	 * end up with a zero length file after a crash.
	 */
7674 7675
	if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
					   &BTRFS_I(inode)->runtime_flags))
7676 7677
		btrfs_add_ordered_operation(trans, root, inode);

J
Josef Bacik 已提交
7678 7679 7680 7681 7682 7683 7684 7685
	/*
	 * So if we truncate and then write and fsync we normally would just
	 * write the extents that changed, which is a problem if we need to
	 * first truncate that entire inode.  So set this flag so we write out
	 * all of the extents in the inode to the sync log so we're completely
	 * safe.
	 */
	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
7686
	trans->block_rsv = rsv;
7687

7688 7689 7690 7691
	while (1) {
		ret = btrfs_truncate_inode_items(trans, root, inode,
						 inode->i_size,
						 BTRFS_EXTENT_DATA_KEY);
7692
		if (ret != -ENOSPC) {
7693
			err = ret;
7694
			break;
7695
		}
C
Chris Mason 已提交
7696

7697
		trans->block_rsv = &root->fs_info->trans_block_rsv;
7698
		ret = btrfs_update_inode(trans, root, inode);
7699 7700 7701 7702
		if (ret) {
			err = ret;
			break;
		}
7703

7704
		btrfs_end_transaction(trans, root);
7705
		btrfs_btree_balance_dirty(root);
7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717

		trans = btrfs_start_transaction(root, 2);
		if (IS_ERR(trans)) {
			ret = err = PTR_ERR(trans);
			trans = NULL;
			break;
		}

		ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
					      rsv, min_size);
		BUG_ON(ret);	/* shouldn't happen */
		trans->block_rsv = rsv;
7718 7719 7720
	}

	if (ret == 0 && inode->i_nlink > 0) {
7721
		trans->block_rsv = root->orphan_block_rsv;
7722
		ret = btrfs_orphan_del(trans, inode);
7723 7724
		if (ret)
			err = ret;
7725 7726
	}

7727 7728 7729 7730 7731
	if (trans) {
		trans->block_rsv = &root->fs_info->trans_block_rsv;
		ret = btrfs_update_inode(trans, root, inode);
		if (ret && !err)
			err = ret;
7732

7733
		ret = btrfs_end_transaction(trans, root);
7734
		btrfs_btree_balance_dirty(root);
7735
	}
7736 7737 7738 7739

out:
	btrfs_free_block_rsv(root, rsv);

7740 7741
	if (ret && !err)
		err = ret;
7742

7743
	return err;
C
Chris Mason 已提交
7744 7745
}

C
Chris Mason 已提交
7746 7747 7748
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
7749
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
7750
			     struct btrfs_root *new_root, u64 new_dirid)
C
Chris Mason 已提交
7751 7752
{
	struct inode *inode;
7753
	int err;
7754
	u64 index = 0;
C
Chris Mason 已提交
7755

7756 7757 7758 7759
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
				new_dirid, new_dirid,
				S_IFDIR | (~current_umask() & S_IRWXUGO),
				&index);
7760
	if (IS_ERR(inode))
C
Christoph Hellwig 已提交
7761
		return PTR_ERR(inode);
C
Chris Mason 已提交
7762 7763 7764
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

M
Miklos Szeredi 已提交
7765
	set_nlink(inode, 1);
7766
	btrfs_i_size_write(inode, 0);
7767

7768
	err = btrfs_update_inode(trans, new_root, inode);
7769

7770
	iput(inode);
7771
	return err;
C
Chris Mason 已提交
7772 7773 7774 7775 7776
}

struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;
Y
Yan, Zheng 已提交
7777
	struct inode *inode;
C
Chris Mason 已提交
7778 7779 7780 7781

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
Y
Yan, Zheng 已提交
7782 7783 7784

	ei->root = NULL;
	ei->generation = 0;
7785
	ei->last_trans = 0;
7786
	ei->last_sub_trans = 0;
7787
	ei->logged_trans = 0;
Y
Yan, Zheng 已提交
7788 7789 7790
	ei->delalloc_bytes = 0;
	ei->disk_i_size = 0;
	ei->flags = 0;
7791
	ei->csum_bytes = 0;
Y
Yan, Zheng 已提交
7792 7793
	ei->index_cnt = (u64)-1;
	ei->last_unlink_trans = 0;
7794
	ei->last_log_commit = 0;
Y
Yan, Zheng 已提交
7795

7796 7797 7798
	spin_lock_init(&ei->lock);
	ei->outstanding_extents = 0;
	ei->reserved_extents = 0;
Y
Yan, Zheng 已提交
7799

7800
	ei->runtime_flags = 0;
7801
	ei->force_compress = BTRFS_COMPRESS_NONE;
Y
Yan, Zheng 已提交
7802

7803 7804
	ei->delayed_node = NULL;

Y
Yan, Zheng 已提交
7805
	inode = &ei->vfs_inode;
7806
	extent_map_tree_init(&ei->extent_tree);
7807 7808
	extent_io_tree_init(&ei->io_tree, &inode->i_data);
	extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
7809 7810
	ei->io_tree.track_uptodate = 1;
	ei->io_failure_tree.track_uptodate = 1;
7811
	atomic_set(&ei->sync_writers, 0);
Y
Yan, Zheng 已提交
7812
	mutex_init(&ei->log_mutex);
7813
	mutex_init(&ei->delalloc_mutex);
7814
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
Y
Yan, Zheng 已提交
7815
	INIT_LIST_HEAD(&ei->delalloc_inodes);
7816
	INIT_LIST_HEAD(&ei->ordered_operations);
Y
Yan, Zheng 已提交
7817 7818 7819
	RB_CLEAR_NODE(&ei->rb_node);

	return inode;
C
Chris Mason 已提交
7820 7821
}

N
Nick Piggin 已提交
7822 7823 7824 7825 7826 7827
static void btrfs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

C
Chris Mason 已提交
7828 7829
void btrfs_destroy_inode(struct inode *inode)
{
7830
	struct btrfs_ordered_extent *ordered;
7831 7832
	struct btrfs_root *root = BTRFS_I(inode)->root;

A
Al Viro 已提交
7833
	WARN_ON(!hlist_empty(&inode->i_dentry));
C
Chris Mason 已提交
7834
	WARN_ON(inode->i_data.nrpages);
7835 7836
	WARN_ON(BTRFS_I(inode)->outstanding_extents);
	WARN_ON(BTRFS_I(inode)->reserved_extents);
7837 7838
	WARN_ON(BTRFS_I(inode)->delalloc_bytes);
	WARN_ON(BTRFS_I(inode)->csum_bytes);
C
Chris Mason 已提交
7839

7840 7841 7842 7843 7844 7845 7846 7847
	/*
	 * This can happen where we create an inode, but somebody else also
	 * created the same inode and we need to destroy the one we already
	 * created.
	 */
	if (!root)
		goto free;

7848 7849 7850 7851 7852 7853
	/*
	 * Make sure we're properly removed from the ordered operation
	 * lists.
	 */
	smp_mb();
	if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
7854
		spin_lock(&root->fs_info->ordered_root_lock);
7855
		list_del_init(&BTRFS_I(inode)->ordered_operations);
7856
		spin_unlock(&root->fs_info->ordered_root_lock);
7857 7858
	}

7859 7860
	if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
		     &BTRFS_I(inode)->runtime_flags)) {
7861 7862
		btrfs_info(root->fs_info, "inode %llu still on the orphan list",
			(unsigned long long)btrfs_ino(inode));
7863
		atomic_dec(&root->orphan_inodes);
7864 7865
	}

C
Chris Mason 已提交
7866
	while (1) {
7867 7868 7869 7870
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
7871 7872 7873
			btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup",
				(unsigned long long)ordered->file_offset,
				(unsigned long long)ordered->len);
7874 7875 7876 7877 7878
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
7879
	inode_tree_del(inode);
7880
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
7881
free:
N
Nick Piggin 已提交
7882
	call_rcu(&inode->i_rcu, btrfs_i_callback);
C
Chris Mason 已提交
7883 7884
}

7885
int btrfs_drop_inode(struct inode *inode)
7886 7887
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
7888

7889 7890 7891
	if (root == NULL)
		return 1;

7892
	/* the snap/subvol tree is on deleting */
7893
	if (btrfs_root_refs(&root->root_item) == 0 &&
7894
	    root != root->fs_info->tree_root)
7895
		return 1;
7896
	else
7897
		return generic_drop_inode(inode);
7898 7899
}

7900
static void init_once(void *foo)
C
Chris Mason 已提交
7901 7902 7903 7904 7905 7906 7907 7908
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
7909 7910 7911 7912 7913
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
C
Chris Mason 已提交
7914 7915 7916 7917 7918 7919 7920 7921
	if (btrfs_inode_cachep)
		kmem_cache_destroy(btrfs_inode_cachep);
	if (btrfs_trans_handle_cachep)
		kmem_cache_destroy(btrfs_trans_handle_cachep);
	if (btrfs_transaction_cachep)
		kmem_cache_destroy(btrfs_transaction_cachep);
	if (btrfs_path_cachep)
		kmem_cache_destroy(btrfs_path_cachep);
7922 7923
	if (btrfs_free_space_cachep)
		kmem_cache_destroy(btrfs_free_space_cachep);
7924 7925
	if (btrfs_delalloc_work_cachep)
		kmem_cache_destroy(btrfs_delalloc_work_cachep);
C
Chris Mason 已提交
7926 7927 7928 7929
}

int btrfs_init_cachep(void)
{
D
David Sterba 已提交
7930
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
7931 7932
			sizeof(struct btrfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
C
Chris Mason 已提交
7933 7934
	if (!btrfs_inode_cachep)
		goto fail;
7935

D
David Sterba 已提交
7936
	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
7937 7938
			sizeof(struct btrfs_trans_handle), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7939 7940
	if (!btrfs_trans_handle_cachep)
		goto fail;
7941

D
David Sterba 已提交
7942
	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
7943 7944
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7945 7946
	if (!btrfs_transaction_cachep)
		goto fail;
7947

D
David Sterba 已提交
7948
	btrfs_path_cachep = kmem_cache_create("btrfs_path",
7949 7950
			sizeof(struct btrfs_path), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7951 7952
	if (!btrfs_path_cachep)
		goto fail;
7953

D
David Sterba 已提交
7954
	btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
7955 7956 7957 7958 7959
			sizeof(struct btrfs_free_space), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
	if (!btrfs_free_space_cachep)
		goto fail;

7960 7961 7962 7963 7964 7965 7966
	btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
			sizeof(struct btrfs_delalloc_work), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
			NULL);
	if (!btrfs_delalloc_work_cachep)
		goto fail;

C
Chris Mason 已提交
7967 7968 7969 7970 7971 7972 7973 7974 7975
	return 0;
fail:
	btrfs_destroy_cachep();
	return -ENOMEM;
}

static int btrfs_getattr(struct vfsmount *mnt,
			 struct dentry *dentry, struct kstat *stat)
{
7976
	u64 delalloc_bytes;
C
Chris Mason 已提交
7977
	struct inode *inode = dentry->d_inode;
D
David Sterba 已提交
7978 7979
	u32 blocksize = inode->i_sb->s_blocksize;

C
Chris Mason 已提交
7980
	generic_fillattr(inode, stat);
7981
	stat->dev = BTRFS_I(inode)->root->anon_dev;
C
Chris Mason 已提交
7982
	stat->blksize = PAGE_CACHE_SIZE;
7983 7984 7985 7986

	spin_lock(&BTRFS_I(inode)->lock);
	delalloc_bytes = BTRFS_I(inode)->delalloc_bytes;
	spin_unlock(&BTRFS_I(inode)->lock);
D
David Sterba 已提交
7987
	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
7988
			ALIGN(delalloc_bytes, blocksize)) >> 9;
C
Chris Mason 已提交
7989 7990 7991
	return 0;
}

C
Chris Mason 已提交
7992 7993
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
7994 7995 7996
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
7997
	struct btrfs_root *dest = BTRFS_I(new_dir)->root;
C
Chris Mason 已提交
7998 7999 8000
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
8001
	u64 index = 0;
8002
	u64 root_objectid;
C
Chris Mason 已提交
8003
	int ret;
L
Li Zefan 已提交
8004
	u64 old_ino = btrfs_ino(old_inode);
C
Chris Mason 已提交
8005

L
Li Zefan 已提交
8006
	if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
8007 8008
		return -EPERM;

8009
	/* we only allow rename subvolume link between subvolumes */
L
Li Zefan 已提交
8010
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
8011 8012
		return -EXDEV;

L
Li Zefan 已提交
8013 8014
	if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
	    (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
C
Chris Mason 已提交
8015
		return -ENOTEMPTY;
8016

8017 8018 8019
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
		return -ENOTEMPTY;
C
Chris Mason 已提交
8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041


	/* check for collisions, even if the  name isn't there */
	ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
			     new_dentry->d_name.name,
			     new_dentry->d_name.len);

	if (ret) {
		if (ret == -EEXIST) {
			/* we shouldn't get
			 * eexist without a new_inode */
			if (!new_inode) {
				WARN_ON(1);
				return ret;
			}
		} else {
			/* maybe -EOVERFLOW */
			return ret;
		}
	}
	ret = 0;

8042 8043 8044 8045 8046
	/*
	 * we're using rename to replace one file with another.
	 * and the replacement file is large.  Start IO on it now so
	 * we don't add too much work to the end of the transaction
	 */
8047
	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
8048 8049 8050
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

8051
	/* close the racy window with snapshot create/destroy ioctl */
L
Li Zefan 已提交
8052
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8053
		down_read(&root->fs_info->subvol_sem);
8054 8055 8056 8057 8058 8059 8060 8061
	/*
	 * We want to reserve the absolute worst case amount of items.  So if
	 * both inodes are subvols and we need to unlink them then that would
	 * require 4 item modifications, but if they are both normal inodes it
	 * would require 5 item modifications, so we'll assume their normal
	 * inodes.  So 5 * 2 is 10, plus 1 for the new link, so 11 total items
	 * should cover the worst case number of items we'll modify.
	 */
8062
	trans = btrfs_start_transaction(root, 11);
8063 8064 8065 8066
	if (IS_ERR(trans)) {
                ret = PTR_ERR(trans);
                goto out_notrans;
        }
8067

8068 8069
	if (dest != root)
		btrfs_record_root_in_trans(trans, dest);
8070

8071 8072 8073
	ret = btrfs_set_inode_index(new_dir, &index);
	if (ret)
		goto out_fail;
8074

L
Li Zefan 已提交
8075
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8076 8077 8078
		/* force full log commit if subvolume involved. */
		root->fs_info->last_trans_log_full_commit = trans->transid;
	} else {
8079 8080 8081
		ret = btrfs_insert_inode_ref(trans, dest,
					     new_dentry->d_name.name,
					     new_dentry->d_name.len,
L
Li Zefan 已提交
8082 8083
					     old_ino,
					     btrfs_ino(new_dir), index);
8084 8085
		if (ret)
			goto out_fail;
8086 8087 8088 8089 8090 8091 8092 8093 8094
		/*
		 * this is an ugly little race, but the rename is required
		 * to make sure that if we crash, the inode is either at the
		 * old name or the new one.  pinning the log transaction lets
		 * us make sure we don't allow a log commit to come in after
		 * we unlink the name but before we add the new name back in.
		 */
		btrfs_pin_log_trans(root);
	}
8095 8096 8097 8098
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
L
Li Zefan 已提交
8099
	if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
8100 8101
		btrfs_add_ordered_operation(trans, root, old_inode);

8102 8103 8104
	inode_inc_iversion(old_dir);
	inode_inc_iversion(new_dir);
	inode_inc_iversion(old_inode);
C
Chris Mason 已提交
8105 8106 8107
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
8108

8109 8110 8111
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

L
Li Zefan 已提交
8112
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8113 8114 8115 8116 8117
		root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
		ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
					old_dentry->d_name.name,
					old_dentry->d_name.len);
	} else {
8118 8119 8120 8121 8122 8123
		ret = __btrfs_unlink_inode(trans, root, old_dir,
					old_dentry->d_inode,
					old_dentry->d_name.name,
					old_dentry->d_name.len);
		if (!ret)
			ret = btrfs_update_inode(trans, root, old_inode);
8124
	}
8125 8126 8127 8128
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
8129 8130

	if (new_inode) {
8131
		inode_inc_iversion(new_inode);
C
Chris Mason 已提交
8132
		new_inode->i_ctime = CURRENT_TIME;
L
Li Zefan 已提交
8133
		if (unlikely(btrfs_ino(new_inode) ==
8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146
			     BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
			root_objectid = BTRFS_I(new_inode)->location.objectid;
			ret = btrfs_unlink_subvol(trans, dest, new_dir,
						root_objectid,
						new_dentry->d_name.name,
						new_dentry->d_name.len);
			BUG_ON(new_inode->i_nlink == 0);
		} else {
			ret = btrfs_unlink_inode(trans, dest, new_dir,
						 new_dentry->d_inode,
						 new_dentry->d_name.name,
						 new_dentry->d_name.len);
		}
8147
		if (!ret && new_inode->i_nlink == 0) {
8148
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
8149
			BUG_ON(ret);
8150
		}
8151 8152 8153 8154
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_fail;
		}
C
Chris Mason 已提交
8155
	}
8156

8157 8158
	ret = btrfs_add_link(trans, new_dir, old_inode,
			     new_dentry->d_name.name,
8159
			     new_dentry->d_name.len, 0, index);
8160 8161 8162 8163
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
8164

L
Li Zefan 已提交
8165
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
8166
		struct dentry *parent = new_dentry->d_parent;
8167
		btrfs_log_new_name(trans, old_inode, old_dir, parent);
8168 8169
		btrfs_end_log_trans(root);
	}
C
Chris Mason 已提交
8170
out_fail:
8171
	btrfs_end_transaction(trans, root);
8172
out_notrans:
L
Li Zefan 已提交
8173
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8174
		up_read(&root->fs_info->subvol_sem);
J
Josef Bacik 已提交
8175

C
Chris Mason 已提交
8176 8177 8178
	return ret;
}

8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221
static void btrfs_run_delalloc_work(struct btrfs_work *work)
{
	struct btrfs_delalloc_work *delalloc_work;

	delalloc_work = container_of(work, struct btrfs_delalloc_work,
				     work);
	if (delalloc_work->wait)
		btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
	else
		filemap_flush(delalloc_work->inode->i_mapping);

	if (delalloc_work->delay_iput)
		btrfs_add_delayed_iput(delalloc_work->inode);
	else
		iput(delalloc_work->inode);
	complete(&delalloc_work->completion);
}

struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
						    int wait, int delay_iput)
{
	struct btrfs_delalloc_work *work;

	work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
	if (!work)
		return NULL;

	init_completion(&work->completion);
	INIT_LIST_HEAD(&work->list);
	work->inode = inode;
	work->wait = wait;
	work->delay_iput = delay_iput;
	work->work.func = btrfs_run_delalloc_work;

	return work;
}

void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
{
	wait_for_completion(&work->completion);
	kmem_cache_free(btrfs_delalloc_work_cachep, work);
}

C
Chris Mason 已提交
8222 8223 8224 8225
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
8226
static int __start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
8227 8228
{
	struct btrfs_inode *binode;
8229
	struct inode *inode;
8230 8231
	struct btrfs_delalloc_work *work, *next;
	struct list_head works;
8232
	struct list_head splice;
8233
	int ret = 0;
8234

8235
	INIT_LIST_HEAD(&works);
8236
	INIT_LIST_HEAD(&splice);
8237

8238 8239
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
8240 8241
	while (!list_empty(&splice)) {
		binode = list_entry(splice.next, struct btrfs_inode,
8242
				    delalloc_inodes);
8243

8244 8245
		list_move_tail(&binode->delalloc_inodes,
			       &root->delalloc_inodes);
8246
		inode = igrab(&binode->vfs_inode);
8247
		if (!inode) {
8248
			cond_resched_lock(&root->delalloc_lock);
8249
			continue;
8250
		}
8251
		spin_unlock(&root->delalloc_lock);
8252 8253 8254 8255 8256

		work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
		if (unlikely(!work)) {
			ret = -ENOMEM;
			goto out;
8257
		}
8258 8259 8260 8261
		list_add_tail(&work->list, &works);
		btrfs_queue_worker(&root->fs_info->flush_workers,
				   &work->work);

8262
		cond_resched();
8263
		spin_lock(&root->delalloc_lock);
8264
	}
8265
	spin_unlock(&root->delalloc_lock);
8266

8267 8268 8269 8270
	list_for_each_entry_safe(work, next, &works, list) {
		list_del_init(&work->list);
		btrfs_wait_and_free_delalloc_work(work);
	}
8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284
	return 0;
out:
	list_for_each_entry_safe(work, next, &works, list) {
		list_del_init(&work->list);
		btrfs_wait_and_free_delalloc_work(work);
	}

	if (!list_empty_careful(&splice)) {
		spin_lock(&root->delalloc_lock);
		list_splice_tail(&splice, &root->delalloc_inodes);
		spin_unlock(&root->delalloc_lock);
	}
	return ret;
}
8285

8286 8287 8288 8289 8290 8291 8292 8293 8294 8295
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
{
	int ret;

	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

	ret = __start_delalloc_inodes(root, delay_iput);
	/*
	 * the filemap_flush will queue IO into the worker threads, but
8296 8297 8298 8299
	 * we have to make sure the IO is actually started and that
	 * ordered extents get created before we return
	 */
	atomic_inc(&root->fs_info->async_submit_draining);
C
Chris Mason 已提交
8300
	while (atomic_read(&root->fs_info->nr_async_submits) ||
8301
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
8302
		wait_event(root->fs_info->async_submit_wait,
8303 8304
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
8305 8306
	}
	atomic_dec(&root->fs_info->async_submit_draining);
8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338
	return ret;
}

int btrfs_start_all_delalloc_inodes(struct btrfs_fs_info *fs_info,
				    int delay_iput)
{
	struct btrfs_root *root;
	struct list_head splice;
	int ret;

	if (fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

	INIT_LIST_HEAD(&splice);

	spin_lock(&fs_info->delalloc_root_lock);
	list_splice_init(&fs_info->delalloc_roots, &splice);
	while (!list_empty(&splice)) {
		root = list_first_entry(&splice, struct btrfs_root,
					delalloc_root);
		root = btrfs_grab_fs_root(root);
		BUG_ON(!root);
		list_move_tail(&root->delalloc_root,
			       &fs_info->delalloc_roots);
		spin_unlock(&fs_info->delalloc_root_lock);

		ret = __start_delalloc_inodes(root, delay_iput);
		btrfs_put_fs_root(root);
		if (ret)
			goto out;

		spin_lock(&fs_info->delalloc_root_lock);
8339
	}
8340
	spin_unlock(&fs_info->delalloc_root_lock);
8341

8342 8343 8344 8345 8346 8347 8348 8349 8350 8351
	atomic_inc(&fs_info->async_submit_draining);
	while (atomic_read(&fs_info->nr_async_submits) ||
	      atomic_read(&fs_info->async_delalloc_pages)) {
		wait_event(fs_info->async_submit_wait,
		   (atomic_read(&fs_info->nr_async_submits) == 0 &&
		    atomic_read(&fs_info->async_delalloc_pages) == 0));
	}
	atomic_dec(&fs_info->async_submit_draining);
	return 0;
out:
8352
	if (!list_empty_careful(&splice)) {
8353 8354 8355
		spin_lock(&fs_info->delalloc_root_lock);
		list_splice_tail(&splice, &fs_info->delalloc_roots);
		spin_unlock(&fs_info->delalloc_root_lock);
8356
	}
8357
	return ret;
8358 8359
}

C
Chris Mason 已提交
8360 8361 8362 8363 8364 8365 8366
static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
			 const char *symname)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_path *path;
	struct btrfs_key key;
8367
	struct inode *inode = NULL;
C
Chris Mason 已提交
8368 8369 8370
	int err;
	int drop_inode = 0;
	u64 objectid;
8371
	u64 index = 0 ;
C
Chris Mason 已提交
8372 8373
	int name_len;
	int datasize;
8374
	unsigned long ptr;
C
Chris Mason 已提交
8375
	struct btrfs_file_extent_item *ei;
8376
	struct extent_buffer *leaf;
C
Chris Mason 已提交
8377 8378 8379 8380

	name_len = strlen(symname) + 1;
	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
		return -ENAMETOOLONG;
8381

J
Josef Bacik 已提交
8382 8383 8384 8385 8386
	/*
	 * 2 items for inode item and ref
	 * 2 items for dir items
	 * 1 item for xattr if selinux is on
	 */
8387 8388 8389
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
8390

8391 8392 8393 8394
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

8395
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
8396
				dentry->d_name.len, btrfs_ino(dir), objectid,
8397
				S_IFLNK|S_IRWXUGO, &index);
8398 8399
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
8400
		goto out_unlock;
8401
	}
C
Chris Mason 已提交
8402

8403
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
8404 8405 8406 8407 8408
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

8409 8410 8411 8412 8413 8414 8415 8416 8417
	/*
	* If the active LSM wants to access the inode during
	* d_instantiate it needs these. Smack checks to see
	* if the filesystem supports xattrs by looking at the
	* ops vector.
	*/
	inode->i_fop = &btrfs_file_operations;
	inode->i_op = &btrfs_file_inode_operations;

8418
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
8419 8420 8421 8422
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
8423
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
8424
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
8425 8426 8427 8428 8429
	}
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
8430 8431 8432 8433 8434
	if (!path) {
		err = -ENOMEM;
		drop_inode = 1;
		goto out_unlock;
	}
L
Li Zefan 已提交
8435
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
8436 8437 8438 8439 8440
	key.offset = 0;
	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
	datasize = btrfs_file_extent_calc_inline_size(name_len);
	err = btrfs_insert_empty_item(trans, root, path, &key,
				      datasize);
8441 8442
	if (err) {
		drop_inode = 1;
8443
		btrfs_free_path(path);
8444 8445
		goto out_unlock;
	}
8446 8447 8448 8449 8450
	leaf = path->nodes[0];
	ei = btrfs_item_ptr(leaf, path->slots[0],
			    struct btrfs_file_extent_item);
	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
	btrfs_set_file_extent_type(leaf, ei,
C
Chris Mason 已提交
8451
				   BTRFS_FILE_EXTENT_INLINE);
C
Chris Mason 已提交
8452 8453 8454 8455 8456
	btrfs_set_file_extent_encryption(leaf, ei, 0);
	btrfs_set_file_extent_compression(leaf, ei, 0);
	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
	btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);

C
Chris Mason 已提交
8457
	ptr = btrfs_file_extent_inline_start(ei);
8458 8459
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
8460
	btrfs_free_path(path);
8461

C
Chris Mason 已提交
8462 8463
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
8464
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
Y
Yan Zheng 已提交
8465
	inode_set_bytes(inode, name_len);
8466
	btrfs_i_size_write(inode, name_len - 1);
8467 8468 8469
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
8470 8471

out_unlock:
8472 8473
	if (!err)
		d_instantiate(dentry, inode);
8474
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
8475 8476 8477 8478
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
8479
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
8480 8481
	return err;
}
8482

8483 8484 8485 8486
static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
				       u64 start, u64 num_bytes, u64 min_size,
				       loff_t actual_len, u64 *alloc_hint,
				       struct btrfs_trans_handle *trans)
Y
Yan Zheng 已提交
8487
{
J
Josef Bacik 已提交
8488 8489
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
Y
Yan Zheng 已提交
8490 8491 8492
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 cur_offset = start;
8493
	u64 i_size;
8494
	u64 cur_bytes;
Y
Yan Zheng 已提交
8495
	int ret = 0;
8496
	bool own_trans = true;
Y
Yan Zheng 已提交
8497

8498 8499
	if (trans)
		own_trans = false;
Y
Yan Zheng 已提交
8500
	while (num_bytes > 0) {
8501 8502 8503 8504 8505 8506
		if (own_trans) {
			trans = btrfs_start_transaction(root, 3);
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				break;
			}
8507 8508
		}

8509 8510 8511
		cur_bytes = min(num_bytes, 256ULL * 1024 * 1024);
		cur_bytes = max(cur_bytes, min_size);
		ret = btrfs_reserve_extent(trans, root, cur_bytes,
8512
					   min_size, 0, *alloc_hint, &ins, 1);
8513
		if (ret) {
8514 8515
			if (own_trans)
				btrfs_end_transaction(trans, root);
8516
			break;
Y
Yan Zheng 已提交
8517
		}
8518

Y
Yan Zheng 已提交
8519 8520 8521
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
Y
Yan, Zheng 已提交
8522
						  ins.offset, 0, 0, 0,
Y
Yan Zheng 已提交
8523
						  BTRFS_FILE_EXTENT_PREALLOC);
8524 8525 8526 8527 8528 8529
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
C
Chris Mason 已提交
8530 8531
		btrfs_drop_extent_cache(inode, cur_offset,
					cur_offset + ins.offset -1, 0);
8532

J
Josef Bacik 已提交
8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544
		em = alloc_extent_map();
		if (!em) {
			set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
				&BTRFS_I(inode)->runtime_flags);
			goto next;
		}

		em->start = cur_offset;
		em->orig_start = cur_offset;
		em->len = ins.offset;
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
8545
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
8546
		em->ram_bytes = ins.offset;
J
Josef Bacik 已提交
8547 8548 8549 8550 8551 8552
		em->bdev = root->fs_info->fs_devices->latest_bdev;
		set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
		em->generation = trans->transid;

		while (1) {
			write_lock(&em_tree->lock);
J
Josef Bacik 已提交
8553
			ret = add_extent_mapping(em_tree, em, 1);
J
Josef Bacik 已提交
8554 8555 8556 8557 8558 8559 8560 8561 8562
			write_unlock(&em_tree->lock);
			if (ret != -EEXIST)
				break;
			btrfs_drop_extent_cache(inode, cur_offset,
						cur_offset + ins.offset - 1,
						0);
		}
		free_extent_map(em);
next:
Y
Yan Zheng 已提交
8563 8564
		num_bytes -= ins.offset;
		cur_offset += ins.offset;
8565
		*alloc_hint = ins.objectid + ins.offset;
8566

8567
		inode_inc_iversion(inode);
Y
Yan Zheng 已提交
8568
		inode->i_ctime = CURRENT_TIME;
8569
		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
Y
Yan Zheng 已提交
8570
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
8571 8572
		    (actual_len > inode->i_size) &&
		    (cur_offset > inode->i_size)) {
8573
			if (cur_offset > actual_len)
8574
				i_size = actual_len;
8575
			else
8576 8577 8578
				i_size = cur_offset;
			i_size_write(inode, i_size);
			btrfs_ordered_update_i_size(inode, i_size, NULL);
8579 8580
		}

Y
Yan Zheng 已提交
8581
		ret = btrfs_update_inode(trans, root, inode);
8582 8583 8584 8585 8586 8587 8588

		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
Y
Yan Zheng 已提交
8589

8590 8591
		if (own_trans)
			btrfs_end_transaction(trans, root);
8592
	}
Y
Yan Zheng 已提交
8593 8594 8595
	return ret;
}

8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613
int btrfs_prealloc_file_range(struct inode *inode, int mode,
			      u64 start, u64 num_bytes, u64 min_size,
			      loff_t actual_len, u64 *alloc_hint)
{
	return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
					   min_size, actual_len, alloc_hint,
					   NULL);
}

int btrfs_prealloc_file_range_trans(struct inode *inode,
				    struct btrfs_trans_handle *trans, int mode,
				    u64 start, u64 num_bytes, u64 min_size,
				    loff_t actual_len, u64 *alloc_hint)
{
	return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
					   min_size, actual_len, alloc_hint, trans);
}

8614 8615 8616 8617 8618
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

8619
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
8620
{
L
Li Zefan 已提交
8621
	struct btrfs_root *root = BTRFS_I(inode)->root;
8622
	umode_t mode = inode->i_mode;
L
Li Zefan 已提交
8623

8624 8625 8626 8627 8628 8629 8630
	if (mask & MAY_WRITE &&
	    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
		if (btrfs_root_readonly(root))
			return -EROFS;
		if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)
			return -EACCES;
	}
8631
	return generic_permission(inode, mask);
Y
Yan 已提交
8632
}
C
Chris Mason 已提交
8633

8634
static const struct inode_operations btrfs_dir_inode_operations = {
8635
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
8636 8637 8638 8639 8640 8641 8642 8643 8644
	.lookup		= btrfs_lookup,
	.create		= btrfs_create,
	.unlink		= btrfs_unlink,
	.link		= btrfs_link,
	.mkdir		= btrfs_mkdir,
	.rmdir		= btrfs_rmdir,
	.rename		= btrfs_rename,
	.symlink	= btrfs_symlink,
	.setattr	= btrfs_setattr,
J
Josef Bacik 已提交
8645
	.mknod		= btrfs_mknod,
8646 8647
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8648
	.listxattr	= btrfs_listxattr,
8649
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
8650
	.permission	= btrfs_permission,
8651
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
8652
};
8653
static const struct inode_operations btrfs_dir_ro_inode_operations = {
C
Chris Mason 已提交
8654
	.lookup		= btrfs_lookup,
Y
Yan 已提交
8655
	.permission	= btrfs_permission,
8656
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
8657
};
8658

8659
static const struct file_operations btrfs_dir_file_operations = {
C
Chris Mason 已提交
8660 8661
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
8662
	.readdir	= btrfs_real_readdir,
C
Christoph Hellwig 已提交
8663
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
8664
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
8665
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
8666
#endif
S
Sage Weil 已提交
8667
	.release        = btrfs_release_file,
8668
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
8669 8670
};

8671
static struct extent_io_ops btrfs_extent_io_ops = {
8672
	.fill_delalloc = run_delalloc_range,
8673
	.submit_bio_hook = btrfs_submit_bio_hook,
8674
	.merge_bio_hook = btrfs_merge_bio_hook,
8675
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
8676
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
8677
	.writepage_start_hook = btrfs_writepage_start_hook,
C
Chris Mason 已提交
8678 8679
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
J
Josef Bacik 已提交
8680 8681
	.merge_extent_hook = btrfs_merge_extent_hook,
	.split_extent_hook = btrfs_split_extent_hook,
8682 8683
};

8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695
/*
 * btrfs doesn't support the bmap operation because swapfiles
 * use bmap to make a mapping of extents in the file.  They assume
 * these extents won't change over the life of the file and they
 * use the bmap result to do IO directly to the drive.
 *
 * the btrfs bmap call would return logical addresses that aren't
 * suitable for IO and they also will change frequently as COW
 * operations happen.  So, swapfile + btrfs == corruption.
 *
 * For now we're avoiding this by dropping bmap.
 */
8696
static const struct address_space_operations btrfs_aops = {
C
Chris Mason 已提交
8697 8698
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
8699
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
8700
	.readpages	= btrfs_readpages,
8701
	.direct_IO	= btrfs_direct_IO,
8702 8703
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
8704
	.set_page_dirty	= btrfs_set_page_dirty,
8705
	.error_remove_page = generic_error_remove_page,
C
Chris Mason 已提交
8706 8707
};

8708
static const struct address_space_operations btrfs_symlink_aops = {
C
Chris Mason 已提交
8709 8710
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
8711 8712
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
8713 8714
};

8715
static const struct inode_operations btrfs_file_inode_operations = {
C
Chris Mason 已提交
8716 8717
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
8718 8719
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8720
	.listxattr      = btrfs_listxattr,
8721
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
8722
	.permission	= btrfs_permission,
Y
Yehuda Sadeh 已提交
8723
	.fiemap		= btrfs_fiemap,
8724
	.get_acl	= btrfs_get_acl,
8725
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8726
};
8727
static const struct inode_operations btrfs_special_inode_operations = {
J
Josef Bacik 已提交
8728 8729
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
8730
	.permission	= btrfs_permission,
8731 8732
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8733
	.listxattr	= btrfs_listxattr,
8734
	.removexattr	= btrfs_removexattr,
8735
	.get_acl	= btrfs_get_acl,
8736
	.update_time	= btrfs_update_time,
J
Josef Bacik 已提交
8737
};
8738
static const struct inode_operations btrfs_symlink_inode_operations = {
C
Chris Mason 已提交
8739 8740 8741
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
8742
	.getattr	= btrfs_getattr,
8743
	.setattr	= btrfs_setattr,
Y
Yan 已提交
8744
	.permission	= btrfs_permission,
J
Jim Owens 已提交
8745 8746 8747 8748
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
8749
	.get_acl	= btrfs_get_acl,
8750
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8751
};
8752

8753
const struct dentry_operations btrfs_dentry_operations = {
8754
	.d_delete	= btrfs_dentry_delete,
8755
	.d_release	= btrfs_dentry_release,
8756
};