inode.c 230.1 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>
35
#include <linux/aio.h>
C
Chris Mason 已提交
36
#include <linux/bit_spinlock.h>
J
Josef Bacik 已提交
37
#include <linux/xattr.h>
J
Josef Bacik 已提交
38
#include <linux/posix_acl.h>
Y
Yan Zheng 已提交
39
#include <linux/falloc.h>
40
#include <linux/slab.h>
41
#include <linux/ratelimit.h>
42
#include <linux/mount.h>
43
#include <linux/btrfs.h>
D
David Woodhouse 已提交
44
#include <linux/blkdev.h>
45
#include <linux/posix_acl_xattr.h>
C
Chris Mason 已提交
46
#include "compat.h"
C
Chris Mason 已提交
47 48 49 50 51
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "print-tree.h"
52
#include "ordered-data.h"
53
#include "xattr.h"
54
#include "tree-log.h"
55
#include "volumes.h"
C
Chris Mason 已提交
56
#include "compression.h"
57
#include "locking.h"
58
#include "free-space-cache.h"
59
#include "inode-map.h"
L
Liu Bo 已提交
60
#include "backref.h"
61
#include "hash.h"
C
Chris Mason 已提交
62 63 64 65 66 67

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

68 69 70 71 72
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;
73 74
static const struct address_space_operations btrfs_aops;
static const struct address_space_operations btrfs_symlink_aops;
75
static const struct file_operations btrfs_dir_file_operations;
76
static struct extent_io_ops btrfs_extent_io_ops;
C
Chris Mason 已提交
77 78

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

#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,
};

96
static int btrfs_setsize(struct inode *inode, struct iattr *attr);
97
static int btrfs_truncate(struct inode *inode);
98
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
99 100 101 102
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);
103 104 105
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 已提交
106 107
					   u64 orig_block_len, u64 ram_bytes,
					   int type);
108

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

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

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

C
Chris Mason 已提交
123 124 125 126 127
/*
 * 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 已提交
128
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
129 130
				struct btrfs_root *root, struct inode *inode,
				u64 start, size_t size, size_t compressed_size,
131
				int compress_type,
C
Chris Mason 已提交
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
				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;

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

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

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

L
Li Zefan 已提交
156
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	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);

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

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

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

209 210 211 212 213 214 215 216 217
	/*
	 * 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 已提交
218
	BTRFS_I(inode)->disk_i_size = inode->i_size;
219
	ret = btrfs_update_inode(trans, root, inode);
220

221
	return ret;
C
Chris Mason 已提交
222 223 224 225 226 227 228 229 230 231 232
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.
 */
233 234 235 236 237
static noinline int cow_file_range_inline(struct btrfs_root *root,
					  struct inode *inode, u64 start,
					  u64 end, size_t compressed_size,
					  int compress_type,
					  struct page **compressed_pages)
C
Chris Mason 已提交
238
{
239
	struct btrfs_trans_handle *trans;
C
Chris Mason 已提交
240 241 242
	u64 isize = i_size_read(inode);
	u64 actual_end = min(end + 1, isize);
	u64 inline_len = actual_end - start;
243
	u64 aligned_end = ALIGN(end, root->sectorsize);
C
Chris Mason 已提交
244 245 246 247 248 249 250
	u64 data_len = inline_len;
	int ret;

	if (compressed_size)
		data_len = compressed_size;

	if (start > 0 ||
C
Chris Mason 已提交
251
	    actual_end >= PAGE_CACHE_SIZE ||
C
Chris Mason 已提交
252 253 254 255 256 257 258 259
	    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;
	}

260 261 262 263 264
	trans = btrfs_join_transaction(root);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

265
	ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
266 267 268 269
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
C
Chris Mason 已提交
270 271 272 273 274

	if (isize > actual_end)
		inline_len = min_t(u64, isize, actual_end);
	ret = insert_inline_extent(trans, root, inode, start,
				   inline_len, compressed_size,
275
				   compress_type, compressed_pages);
276
	if (ret && ret != -ENOSPC) {
277
		btrfs_abort_transaction(trans, root, ret);
278
		goto out;
279
	} else if (ret == -ENOSPC) {
280 281
		ret = 1;
		goto out;
282
	}
283

284
	set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
285
	btrfs_delalloc_release_metadata(inode, end + 1 - start);
C
Chris Mason 已提交
286
	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
287 288 289
out:
	btrfs_end_transaction(trans, root);
	return ret;
C
Chris Mason 已提交
290 291
}

292 293 294 295 296 297
struct async_extent {
	u64 start;
	u64 ram_size;
	u64 compressed_size;
	struct page **pages;
	unsigned long nr_pages;
298
	int compress_type;
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
	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,
316 317
				     unsigned long nr_pages,
				     int compress_type)
318 319 320 321
{
	struct async_extent *async_extent;

	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
322
	BUG_ON(!async_extent); /* -ENOMEM */
323 324 325 326 327
	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;
328
	async_extent->compress_type = compress_type;
329 330 331 332
	list_add_tail(&async_extent->list, &cow->extents);
	return 0;
}

C
Chris Mason 已提交
333
/*
334 335 336
 * 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 已提交
337
 *
338 339 340 341 342
 * 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 已提交
343
 *
344 345 346
 * 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
347 348
 * are written in the same order that the flusher thread sent them
 * down.
C
Chris Mason 已提交
349
 */
350 351 352 353 354
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)
355 356
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
357 358
	u64 num_bytes;
	u64 blocksize = root->sectorsize;
C
Chris Mason 已提交
359
	u64 actual_end;
360
	u64 isize = i_size_read(inode);
361
	int ret = 0;
C
Chris Mason 已提交
362 363 364 365 366 367
	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;
368
	unsigned long max_uncompressed = 128 * 1024;
C
Chris Mason 已提交
369 370
	int i;
	int will_compress;
371
	int compress_type = root->fs_info->compress_type;
372
	int redirty = 0;
373

374 375 376
	/* 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 已提交
377 378
		btrfs_add_inode_defrag(NULL, inode);

379
	actual_end = min_t(u64, isize, end + 1);
C
Chris Mason 已提交
380 381 382 383
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);
384

385 386 387 388 389 390 391 392 393 394 395 396 397
	/*
	 * 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 已提交
398 399 400 401
	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
402 403 404 405 406 407 408
	 * 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 已提交
409 410
	 */
	total_compressed = min(total_compressed, max_uncompressed);
411
	num_bytes = ALIGN(end - start + 1, blocksize);
412
	num_bytes = max(blocksize,  num_bytes);
C
Chris Mason 已提交
413 414
	total_in = 0;
	ret = 0;
415

416 417 418 419
	/*
	 * 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 已提交
420
	 */
421
	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
C
Chris Mason 已提交
422
	    (btrfs_test_opt(root, COMPRESS) ||
423 424
	     (BTRFS_I(inode)->force_compress) ||
	     (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
C
Chris Mason 已提交
425
		WARN_ON(pages);
426
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
427 428 429 430
		if (!pages) {
			/* just bail out to the uncompressed code */
			goto cont;
		}
C
Chris Mason 已提交
431

432 433 434
		if (BTRFS_I(inode)->force_compress)
			compress_type = BTRFS_I(inode)->force_compress;

435 436 437 438 439 440 441 442 443 444 445
		/*
		 * 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;
446 447 448 449 450 451 452
		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 已提交
453 454 455 456 457 458 459 460 461 462 463

		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) {
464
				kaddr = kmap_atomic(page);
C
Chris Mason 已提交
465 466
				memset(kaddr + offset, 0,
				       PAGE_CACHE_SIZE - offset);
467
				kunmap_atomic(kaddr);
C
Chris Mason 已提交
468 469 470 471
			}
			will_compress = 1;
		}
	}
472
cont:
C
Chris Mason 已提交
473 474
	if (start == 0) {
		/* lets try to make an inline extent */
475
		if (ret || total_in < (actual_end - start)) {
C
Chris Mason 已提交
476
			/* we didn't compress the entire range, try
477
			 * to make an uncompressed inline extent.
C
Chris Mason 已提交
478
			 */
479 480
			ret = cow_file_range_inline(root, inode, start, end,
						    0, 0, NULL);
C
Chris Mason 已提交
481
		} else {
482
			/* try making a compressed inline extent */
483
			ret = cow_file_range_inline(root, inode, start, end,
484 485
						    total_compressed,
						    compress_type, pages);
C
Chris Mason 已提交
486
		}
487
		if (ret <= 0) {
488 489 490 491
			unsigned long clear_flags = EXTENT_DELALLOC |
				EXTENT_DEFRAG;
			clear_flags |= (ret < 0) ? EXTENT_DO_ACCOUNTING : 0;

492
			/*
493 494 495
			 * 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.
496
			 */
497
			extent_clear_unlock_delalloc(inode, start, end, NULL,
498
						     clear_flags, PAGE_UNLOCK |
499 500 501
						     PAGE_CLEAR_DIRTY |
						     PAGE_SET_WRITEBACK |
						     PAGE_END_WRITEBACK);
C
Chris Mason 已提交
502 503 504 505 506 507 508 509 510 511
			goto free_pages_out;
		}
	}

	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
		 */
512
		total_compressed = ALIGN(total_compressed, blocksize);
C
Chris Mason 已提交
513 514 515 516 517

		/*
		 * one last check to make sure the compression is really a
		 * win, compare the page count read with the blocks on disk
		 */
518
		total_in = ALIGN(total_in, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
519 520 521 522 523 524 525 526 527 528 529 530
		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 已提交
531
			WARN_ON(pages[i]->mapping);
C
Chris Mason 已提交
532 533 534 535 536 537 538 539
			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 已提交
540 541
		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
		    !(BTRFS_I(inode)->force_compress)) {
C
Chris Mason 已提交
542
			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
C
Chris Mason 已提交
543
		}
C
Chris Mason 已提交
544
	}
545 546
	if (will_compress) {
		*num_added += 1;
C
Chris Mason 已提交
547

548 549 550 551 552
		/* 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,
553 554
				 total_compressed, pages, nr_pages_ret,
				 compress_type);
555

556
		if (start + num_bytes < end) {
557 558 559 560 561 562
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
563
cleanup_and_bail_uncompressed:
564 565 566 567 568 569 570 571 572 573 574 575
		/*
		 * 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 */
		}
576 577
		if (redirty)
			extent_range_redirty_for_io(inode, start, end);
578 579
		add_async_extent(async_cow, start, end - start + 1,
				 0, NULL, 0, BTRFS_COMPRESS_NONE);
580 581
		*num_added += 1;
	}
582

583
out:
584
	return ret;
585 586 587 588 589 590

free_pages_out:
	for (i = 0; i < nr_pages_ret; i++) {
		WARN_ON(pages[i]->mapping);
		page_cache_release(pages[i]);
	}
C
Chris Mason 已提交
591
	kfree(pages);
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611

	goto out;
}

/*
 * 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_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;
612
	int ret = 0;
613 614 615 616

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

617
again:
C
Chris Mason 已提交
618
	while (!list_empty(&async_cow->extents)) {
619 620 621
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
C
Chris Mason 已提交
622

623 624
		io_tree = &BTRFS_I(inode)->io_tree;

625
retry:
626 627 628 629 630 631
		/* 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,
632
					 async_extent->start +
633
					 async_extent->ram_size - 1);
634 635

			/* allocate blocks */
636 637 638 639 640
			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);
641

642 643
			/* JDM XXX */

644 645 646 647 648 649
			/*
			 * 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.
			 */
650
			if (!page_started && !ret)
651 652
				extent_write_locked_range(io_tree,
						  inode, async_extent->start,
C
Chris Mason 已提交
653
						  async_extent->start +
654 655 656
						  async_extent->ram_size - 1,
						  btrfs_get_extent,
						  WB_SYNC_ALL);
657 658
			else if (ret)
				unlock_page(async_cow->locked_page);
659 660 661 662 663 664
			kfree(async_extent);
			cond_resched();
			continue;
		}

		lock_extent(io_tree, async_extent->start,
665
			    async_extent->start + async_extent->ram_size - 1);
666

667
		ret = btrfs_reserve_extent(root,
668 669
					   async_extent->compressed_size,
					   async_extent->compressed_size,
670
					   0, alloc_hint, &ins, 1);
671 672
		if (ret) {
			int i;
673

674 675 676 677 678 679 680
			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;
681

682 683 684 685
			if (ret == -ENOSPC) {
				unlock_extent(io_tree, async_extent->start,
					      async_extent->start +
					      async_extent->ram_size - 1);
686
				goto retry;
687
			}
688
			goto out_free;
689 690
		}

691 692 693 694 695 696 697 698
		/*
		 * 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);

699
		em = alloc_extent_map();
700 701
		if (!em) {
			ret = -ENOMEM;
702
			goto out_free_reserve;
703
		}
704 705
		em->start = async_extent->start;
		em->len = async_extent->ram_size;
706
		em->orig_start = em->start;
707 708
		em->mod_start = em->start;
		em->mod_len = em->len;
C
Chris Mason 已提交
709

710 711
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
712
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
713
		em->ram_bytes = async_extent->ram_size;
714
		em->bdev = root->fs_info->fs_devices->latest_bdev;
715
		em->compress_type = async_extent->compress_type;
716 717
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
718
		em->generation = -1;
719

C
Chris Mason 已提交
720
		while (1) {
721
			write_lock(&em_tree->lock);
J
Josef Bacik 已提交
722
			ret = add_extent_mapping(em_tree, em, 1);
723
			write_unlock(&em_tree->lock);
724 725 726 727 728 729 730 731 732
			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);
		}

733 734 735
		if (ret)
			goto out_free_reserve;

736 737 738 739 740 741 742
		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);
743 744
		if (ret)
			goto out_free_reserve;
745 746 747 748

		/*
		 * clear dirty, set writeback and unlock the pages.
		 */
749
		extent_clear_unlock_delalloc(inode, async_extent->start,
750 751
				async_extent->start +
				async_extent->ram_size - 1,
752 753
				NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
				PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
754
				PAGE_SET_WRITEBACK);
755
		ret = btrfs_submit_compressed_write(inode,
C
Chris Mason 已提交
756 757 758 759 760
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
761 762
		alloc_hint = ins.objectid + ins.offset;
		kfree(async_extent);
763 764
		if (ret)
			goto out;
765 766
		cond_resched();
	}
767 768 769
	ret = 0;
out:
	return ret;
770 771
out_free_reserve:
	btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
772
out_free:
773
	extent_clear_unlock_delalloc(inode, async_extent->start,
774 775
				     async_extent->start +
				     async_extent->ram_size - 1,
776
				     NULL, EXTENT_LOCKED | EXTENT_DELALLOC |
777 778 779
				     EXTENT_DEFRAG | EXTENT_DO_ACCOUNTING,
				     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
				     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK);
780
	kfree(async_extent);
781
	goto again;
782 783
}

784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
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;
}

816 817 818 819 820 821 822 823 824 825 826 827 828
/*
 * 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.
 */
829 830 831 832 833
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)
834
{
835
	struct btrfs_root *root = BTRFS_I(inode)->root;
836 837 838 839 840 841 842 843 844 845 846
	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;

847
	BUG_ON(btrfs_is_free_space_inode(inode));
848

849
	num_bytes = ALIGN(end - start + 1, blocksize);
850 851 852
	num_bytes = max(blocksize,  num_bytes);
	disk_num_bytes = num_bytes;

C
Chris Mason 已提交
853
	/* if this is a small write inside eof, kick off defrag */
854 855
	if (num_bytes < 64 * 1024 &&
	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
856
		btrfs_add_inode_defrag(NULL, inode);
C
Chris Mason 已提交
857

858 859
	if (start == 0) {
		/* lets try to make an inline extent */
860 861
		ret = cow_file_range_inline(root, inode, start, end, 0, 0,
					    NULL);
862
		if (ret == 0) {
863 864
			extent_clear_unlock_delalloc(inode, start, end, NULL,
				     EXTENT_LOCKED | EXTENT_DELALLOC |
865
				     EXTENT_DEFRAG, PAGE_UNLOCK |
866 867
				     PAGE_CLEAR_DIRTY | PAGE_SET_WRITEBACK |
				     PAGE_END_WRITEBACK);
868

869 870 871 872
			*nr_written = *nr_written +
			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
			*page_started = 1;
			goto out;
873 874
		} else if (ret < 0) {
			goto out_unlock;
875 876 877 878
		}
	}

	BUG_ON(disk_num_bytes >
879
	       btrfs_super_total_bytes(root->fs_info->super_copy));
880

881
	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
882 883
	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

C
Chris Mason 已提交
884
	while (disk_num_bytes > 0) {
885 886
		unsigned long op;

887
		cur_alloc_size = disk_num_bytes;
888
		ret = btrfs_reserve_extent(root, cur_alloc_size,
889
					   root->sectorsize, 0, alloc_hint,
890
					   &ins, 1);
891
		if (ret < 0)
892
			goto out_unlock;
C
Chris Mason 已提交
893

894
		em = alloc_extent_map();
895 896
		if (!em) {
			ret = -ENOMEM;
897
			goto out_reserve;
898
		}
899
		em->start = start;
900
		em->orig_start = em->start;
901 902
		ram_size = ins.offset;
		em->len = ins.offset;
903 904
		em->mod_start = em->start;
		em->mod_len = em->len;
C
Chris Mason 已提交
905

906
		em->block_start = ins.objectid;
C
Chris Mason 已提交
907
		em->block_len = ins.offset;
908
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
909
		em->ram_bytes = ram_size;
910
		em->bdev = root->fs_info->fs_devices->latest_bdev;
911
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
912
		em->generation = -1;
C
Chris Mason 已提交
913

C
Chris Mason 已提交
914
		while (1) {
915
			write_lock(&em_tree->lock);
J
Josef Bacik 已提交
916
			ret = add_extent_mapping(em_tree, em, 1);
917
			write_unlock(&em_tree->lock);
918 919 920 921 922
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, start,
C
Chris Mason 已提交
923
						start + ram_size - 1, 0);
924
		}
925 926
		if (ret)
			goto out_reserve;
927

928
		cur_alloc_size = ins.offset;
929
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
930
					       ram_size, cur_alloc_size, 0);
931 932
		if (ret)
			goto out_reserve;
C
Chris Mason 已提交
933

934 935 936 937
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, start,
						      cur_alloc_size);
938
			if (ret)
939
				goto out_reserve;
940 941
		}

C
Chris Mason 已提交
942
		if (disk_num_bytes < cur_alloc_size)
943
			break;
C
Chris Mason 已提交
944

C
Chris Mason 已提交
945 946 947
		/* 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
948 949 950
		 *
		 * Do set the Private2 bit so we know this page was properly
		 * setup for writepage
C
Chris Mason 已提交
951
		 */
952 953
		op = unlock ? PAGE_UNLOCK : 0;
		op |= PAGE_SET_PRIVATE2;
954

955 956 957 958
		extent_clear_unlock_delalloc(inode, start,
					     start + ram_size - 1, locked_page,
					     EXTENT_LOCKED | EXTENT_DELALLOC,
					     op);
C
Chris Mason 已提交
959
		disk_num_bytes -= cur_alloc_size;
960 961 962
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
963
	}
964
out:
965
	return ret;
966

967 968
out_reserve:
	btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
969
out_unlock:
970
	extent_clear_unlock_delalloc(inode, start, end, locked_page,
971 972 973 974
				     EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
				     EXTENT_DELALLOC | EXTENT_DEFRAG,
				     PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
				     PAGE_SET_WRITEBACK | PAGE_END_WRITEBACK);
975
	goto out;
976
}
C
Chris Mason 已提交
977

978 979 980 981 982 983 984 985 986 987 988 989
/*
 * 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);
990
	if (num_added == 0) {
991
		btrfs_add_delayed_iput(async_cow->inode);
992
		async_cow->inode = NULL;
993
	}
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
}

/*
 * 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;

1011
	if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
1012
	    5 * 1024 * 1024 &&
1013 1014 1015
	    waitqueue_active(&root->fs_info->async_submit_wait))
		wake_up(&root->fs_info->async_submit_wait);

C
Chris Mason 已提交
1016
	if (async_cow->inode)
1017 1018
		submit_compressed_extents(async_cow->inode, async_cow);
}
C
Chris Mason 已提交
1019

1020 1021 1022 1023
static noinline void async_cow_free(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	async_cow = container_of(work, struct async_cow, work);
1024
	if (async_cow->inode)
1025
		btrfs_add_delayed_iput(async_cow->inode);
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	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;
1037
	int limit = 10 * 1024 * 1024;
1038

1039 1040
	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
			 1, 0, NULL, GFP_NOFS);
C
Chris Mason 已提交
1041
	while (start < end) {
1042
		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
1043
		BUG_ON(!async_cow); /* -ENOMEM */
1044
		async_cow->inode = igrab(inode);
1045 1046 1047 1048
		async_cow->root = root;
		async_cow->locked_page = locked_page;
		async_cow->start = start;

1049
		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
			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 已提交
1075
		while (atomic_read(&root->fs_info->async_submit_draining) &&
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
		      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;
1087 1088
}

C
Chris Mason 已提交
1089
static noinline int csum_exist_in_range(struct btrfs_root *root,
1090 1091 1092 1093 1094 1095
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

Y
Yan Zheng 已提交
1096
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
A
Arne Jansen 已提交
1097
				       bytenr + num_bytes - 1, &list, 0);
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
	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 已提交
1109 1110 1111 1112 1113 1114 1115
/*
 * 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
 */
1116 1117
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
1118 1119
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
1120 1121
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1122
	struct btrfs_trans_handle *trans;
1123 1124
	struct extent_buffer *leaf;
	struct btrfs_path *path;
Y
Yan Zheng 已提交
1125
	struct btrfs_file_extent_item *fi;
1126
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
1127 1128 1129
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
1130
	u64 extent_offset;
Y
Yan Zheng 已提交
1131 1132
	u64 disk_bytenr;
	u64 num_bytes;
1133
	u64 disk_num_bytes;
J
Josef Bacik 已提交
1134
	u64 ram_bytes;
Y
Yan Zheng 已提交
1135
	int extent_type;
1136
	int ret, err;
Y
Yan Zheng 已提交
1137
	int type;
Y
Yan Zheng 已提交
1138 1139
	int nocow;
	int check_prev = 1;
1140
	bool nolock;
L
Li Zefan 已提交
1141
	u64 ino = btrfs_ino(inode);
1142 1143

	path = btrfs_alloc_path();
1144
	if (!path) {
1145 1146
		extent_clear_unlock_delalloc(inode, start, end, locked_page,
					     EXTENT_LOCKED | EXTENT_DELALLOC |
1147 1148
					     EXTENT_DO_ACCOUNTING |
					     EXTENT_DEFRAG, PAGE_UNLOCK |
1149 1150 1151
					     PAGE_CLEAR_DIRTY |
					     PAGE_SET_WRITEBACK |
					     PAGE_END_WRITEBACK);
1152
		return -ENOMEM;
1153
	}
1154

1155
	nolock = btrfs_is_free_space_inode(inode);
1156 1157

	if (nolock)
1158
		trans = btrfs_join_transaction_nolock(root);
1159
	else
1160
		trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
1161

1162
	if (IS_ERR(trans)) {
1163 1164
		extent_clear_unlock_delalloc(inode, start, end, locked_page,
					     EXTENT_LOCKED | EXTENT_DELALLOC |
1165 1166
					     EXTENT_DO_ACCOUNTING |
					     EXTENT_DEFRAG, PAGE_UNLOCK |
1167 1168 1169
					     PAGE_CLEAR_DIRTY |
					     PAGE_SET_WRITEBACK |
					     PAGE_END_WRITEBACK);
1170 1171 1172 1173
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}

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

Y
Yan Zheng 已提交
1176 1177 1178
	cow_start = (u64)-1;
	cur_offset = start;
	while (1) {
L
Li Zefan 已提交
1179
		ret = btrfs_lookup_file_extent(trans, root, path, ino,
Y
Yan Zheng 已提交
1180
					       cur_offset, 0);
1181 1182 1183 1184
		if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
Y
Yan Zheng 已提交
1185 1186 1187 1188
		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 已提交
1189
			if (found_key.objectid == ino &&
Y
Yan Zheng 已提交
1190 1191 1192 1193 1194 1195 1196 1197
			    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);
1198 1199 1200 1201
			if (ret < 0) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
Y
Yan Zheng 已提交
1202 1203 1204 1205
			if (ret > 0)
				break;
			leaf = path->nodes[0];
		}
1206

Y
Yan Zheng 已提交
1207 1208
		nocow = 0;
		disk_bytenr = 0;
1209
		num_bytes = 0;
Y
Yan Zheng 已提交
1210 1211
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

L
Li Zefan 已提交
1212
		if (found_key.objectid > ino ||
Y
Yan Zheng 已提交
1213 1214 1215 1216 1217 1218
		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
		    found_key.offset > end)
			break;

		if (found_key.offset > cur_offset) {
			extent_end = found_key.offset;
1219
			extent_type = 0;
Y
Yan Zheng 已提交
1220 1221 1222 1223 1224 1225 1226
			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 已提交
1227
		ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
Y
Yan Zheng 已提交
1228 1229
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
1230
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1231
			extent_offset = btrfs_file_extent_offset(leaf, fi);
Y
Yan Zheng 已提交
1232 1233
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
1234 1235
			disk_num_bytes =
				btrfs_file_extent_disk_num_bytes(leaf, fi);
Y
Yan Zheng 已提交
1236 1237 1238 1239
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1240 1241
			if (disk_bytenr == 0)
				goto out_check;
Y
Yan Zheng 已提交
1242 1243 1244 1245
			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 已提交
1246 1247
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1248
			if (btrfs_extent_readonly(root, disk_bytenr))
Y
Yan Zheng 已提交
1249
				goto out_check;
L
Li Zefan 已提交
1250
			if (btrfs_cross_ref_exist(trans, root, ino,
1251 1252
						  found_key.offset -
						  extent_offset, disk_bytenr))
1253
				goto out_check;
1254
			disk_bytenr += extent_offset;
1255 1256 1257 1258 1259 1260 1261 1262 1263
			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 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
			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;
1285 1286
		}

1287
		btrfs_release_path(path);
Y
Yan Zheng 已提交
1288
		if (cow_start != (u64)-1) {
1289 1290 1291
			ret = cow_file_range(inode, locked_page,
					     cow_start, found_key.offset - 1,
					     page_started, nr_written, 1);
1292 1293 1294 1295
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
Y
Yan Zheng 已提交
1296
			cow_start = (u64)-1;
1297
		}
Y
Yan Zheng 已提交
1298

Y
Yan Zheng 已提交
1299 1300 1301 1302
		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
			struct extent_map *em;
			struct extent_map_tree *em_tree;
			em_tree = &BTRFS_I(inode)->extent_tree;
1303
			em = alloc_extent_map();
1304
			BUG_ON(!em); /* -ENOMEM */
Y
Yan Zheng 已提交
1305
			em->start = cur_offset;
1306
			em->orig_start = found_key.offset - extent_offset;
Y
Yan Zheng 已提交
1307 1308 1309
			em->len = num_bytes;
			em->block_len = num_bytes;
			em->block_start = disk_bytenr;
1310
			em->orig_block_len = disk_num_bytes;
J
Josef Bacik 已提交
1311
			em->ram_bytes = ram_bytes;
Y
Yan Zheng 已提交
1312
			em->bdev = root->fs_info->fs_devices->latest_bdev;
1313 1314
			em->mod_start = em->start;
			em->mod_len = em->len;
Y
Yan Zheng 已提交
1315
			set_bit(EXTENT_FLAG_PINNED, &em->flags);
1316
			set_bit(EXTENT_FLAG_FILLING, &em->flags);
1317
			em->generation = -1;
Y
Yan Zheng 已提交
1318
			while (1) {
1319
				write_lock(&em_tree->lock);
J
Josef Bacik 已提交
1320
				ret = add_extent_mapping(em_tree, em, 1);
1321
				write_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
				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 已提交
1333 1334

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
Y
Yan Zheng 已提交
1335
					       num_bytes, num_bytes, type);
1336
		BUG_ON(ret); /* -ENOMEM */
1337

1338 1339 1340 1341
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, cur_offset,
						      num_bytes);
1342 1343 1344 1345
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
1346 1347
		}

1348 1349 1350 1351 1352
		extent_clear_unlock_delalloc(inode, cur_offset,
					     cur_offset + num_bytes - 1,
					     locked_page, EXTENT_LOCKED |
					     EXTENT_DELALLOC, PAGE_UNLOCK |
					     PAGE_SET_PRIVATE2);
Y
Yan Zheng 已提交
1353 1354 1355
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1356
	}
1357
	btrfs_release_path(path);
Y
Yan Zheng 已提交
1358

1359
	if (cur_offset <= end && cow_start == (u64)-1) {
Y
Yan Zheng 已提交
1360
		cow_start = cur_offset;
1361 1362 1363
		cur_offset = end;
	}

Y
Yan Zheng 已提交
1364
	if (cow_start != (u64)-1) {
1365 1366
		ret = cow_file_range(inode, locked_page, cow_start, end,
				     page_started, nr_written, 1);
1367 1368 1369 1370
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
Y
Yan Zheng 已提交
1371 1372
	}

1373
error:
1374
	err = btrfs_end_transaction(trans, root);
1375 1376 1377
	if (!ret)
		ret = err;

1378
	if (ret && cur_offset < end)
1379 1380
		extent_clear_unlock_delalloc(inode, cur_offset, end,
					     locked_page, EXTENT_LOCKED |
1381 1382 1383
					     EXTENT_DELALLOC | EXTENT_DEFRAG |
					     EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
					     PAGE_CLEAR_DIRTY |
1384 1385
					     PAGE_SET_WRITEBACK |
					     PAGE_END_WRITEBACK);
1386
	btrfs_free_path(path);
1387
	return ret;
1388 1389
}

C
Chris Mason 已提交
1390 1391 1392
/*
 * extent_io.c call back to do delayed allocation processing
 */
C
Chris Mason 已提交
1393
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1394 1395
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1396 1397
{
	int ret;
1398
	struct btrfs_root *root = BTRFS_I(inode)->root;
1399

1400
	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
C
Chris Mason 已提交
1401
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1402
					 page_started, 1, nr_written);
1403
	} else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
Y
Yan Zheng 已提交
1404
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1405
					 page_started, 0, nr_written);
1406 1407 1408
	} else if (!btrfs_test_opt(root, COMPRESS) &&
		   !(BTRFS_I(inode)->force_compress) &&
		   !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
1409 1410
		ret = cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
1411 1412 1413
	} else {
		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
			&BTRFS_I(inode)->runtime_flags);
1414
		ret = cow_file_range_async(inode, locked_page, start, end,
C
Chris Mason 已提交
1415
					   page_started, nr_written);
1416
	}
1417 1418 1419
	return ret;
}

1420 1421
static void btrfs_split_extent_hook(struct inode *inode,
				    struct extent_state *orig, u64 split)
J
Josef Bacik 已提交
1422
{
1423
	/* not delalloc, ignore it */
J
Josef Bacik 已提交
1424
	if (!(orig->state & EXTENT_DELALLOC))
1425
		return;
J
Josef Bacik 已提交
1426

1427 1428 1429
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;
	spin_unlock(&BTRFS_I(inode)->lock);
J
Josef Bacik 已提交
1430 1431 1432 1433 1434 1435 1436 1437
}

/*
 * 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.
 */
1438 1439 1440
static void btrfs_merge_extent_hook(struct inode *inode,
				    struct extent_state *new,
				    struct extent_state *other)
J
Josef Bacik 已提交
1441 1442 1443
{
	/* not delalloc, ignore it */
	if (!(other->state & EXTENT_DELALLOC))
1444
		return;
J
Josef Bacik 已提交
1445

1446 1447 1448
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents--;
	spin_unlock(&BTRFS_I(inode)->lock);
J
Josef Bacik 已提交
1449 1450
}

1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
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 已提交
1491 1492 1493 1494 1495
/*
 * 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.
 */
1496
static void btrfs_set_bit_hook(struct inode *inode,
1497
			       struct extent_state *state, unsigned long *bits)
1498
{
J
Josef Bacik 已提交
1499

1500 1501
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1502
	 * but in this case, we are only testing for the DELALLOC
1503 1504
	 * bit, which is only set or cleared with irqs on
	 */
1505
	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1506
		struct btrfs_root *root = BTRFS_I(inode)->root;
1507
		u64 len = state->end + 1 - state->start;
1508
		bool do_list = !btrfs_is_free_space_inode(inode);
J
Josef Bacik 已提交
1509

1510
		if (*bits & EXTENT_FIRST_DELALLOC) {
1511
			*bits &= ~EXTENT_FIRST_DELALLOC;
1512 1513 1514 1515 1516
		} else {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents++;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1517

1518 1519
		__percpu_counter_add(&root->fs_info->delalloc_bytes, len,
				     root->fs_info->delalloc_batch);
1520
		spin_lock(&BTRFS_I(inode)->lock);
1521
		BTRFS_I(inode)->delalloc_bytes += len;
1522
		if (do_list && !test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1523 1524
					 &BTRFS_I(inode)->runtime_flags))
			btrfs_add_delalloc_inodes(root, inode);
1525
		spin_unlock(&BTRFS_I(inode)->lock);
1526 1527 1528
	}
}

C
Chris Mason 已提交
1529 1530 1531
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1532
static void btrfs_clear_bit_hook(struct inode *inode,
1533 1534
				 struct extent_state *state,
				 unsigned long *bits)
1535
{
1536 1537
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1538
	 * but in this case, we are only testing for the DELALLOC
1539 1540
	 * bit, which is only set or cleared with irqs on
	 */
1541
	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1542
		struct btrfs_root *root = BTRFS_I(inode)->root;
1543
		u64 len = state->end + 1 - state->start;
1544
		bool do_list = !btrfs_is_free_space_inode(inode);
1545

1546
		if (*bits & EXTENT_FIRST_DELALLOC) {
1547
			*bits &= ~EXTENT_FIRST_DELALLOC;
1548 1549 1550 1551 1552
		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents--;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1553

1554 1555 1556 1557 1558 1559 1560
		/*
		 * We don't reserve metadata space for space cache inodes so we
		 * don't need to call dellalloc_release_metadata if there is an
		 * error.
		 */
		if (*bits & EXTENT_DO_ACCOUNTING &&
		    root != root->fs_info->tree_root)
1561 1562
			btrfs_delalloc_release_metadata(inode, len);

J
Josef Bacik 已提交
1563
		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
1564
		    && do_list && !(state->state & EXTENT_NORESERVE))
1565
			btrfs_free_reserved_data_space(inode, len);
J
Josef Bacik 已提交
1566

1567 1568
		__percpu_counter_add(&root->fs_info->delalloc_bytes, -len,
				     root->fs_info->delalloc_batch);
1569
		spin_lock(&BTRFS_I(inode)->lock);
1570
		BTRFS_I(inode)->delalloc_bytes -= len;
J
Josef Bacik 已提交
1571
		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1572
		    test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1573 1574
			     &BTRFS_I(inode)->runtime_flags))
			btrfs_del_delalloc_inode(root, inode);
1575
		spin_unlock(&BTRFS_I(inode)->lock);
1576 1577 1578
	}
}

C
Chris Mason 已提交
1579 1580 1581 1582
/*
 * 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
 */
1583
int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
C
Chris Mason 已提交
1584 1585
			 size_t size, struct bio *bio,
			 unsigned long bio_flags)
1586 1587
{
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1588
	u64 logical = (u64)bio->bi_sector << 9;
1589 1590 1591 1592
	u64 length = 0;
	u64 map_length;
	int ret;

1593 1594 1595
	if (bio_flags & EXTENT_BIO_COMPRESSED)
		return 0;

1596
	length = bio->bi_size;
1597
	map_length = length;
1598
	ret = btrfs_map_block(root->fs_info, rw, logical,
1599
			      &map_length, NULL, 0);
1600
	/* Will always return 0 with map_multi == NULL */
1601
	BUG_ON(ret < 0);
C
Chris Mason 已提交
1602
	if (map_length < length + size)
1603
		return 1;
1604
	return 0;
1605 1606
}

C
Chris Mason 已提交
1607 1608 1609 1610 1611 1612 1613 1614
/*
 * 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 已提交
1615 1616
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
1617 1618
				    unsigned long bio_flags,
				    u64 bio_offset)
1619 1620 1621
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1622

1623
	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1624
	BUG_ON(ret); /* -ENOMEM */
C
Chris Mason 已提交
1625 1626
	return 0;
}
1627

C
Chris Mason 已提交
1628 1629 1630 1631 1632 1633 1634 1635
/*
 * 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
 */
1636
static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1637 1638
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
C
Chris Mason 已提交
1639 1640
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1641 1642 1643 1644 1645 1646
	int ret;

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

C
Chris Mason 已提交
1649
/*
1650 1651
 * 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 已提交
1652
 */
1653
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1654 1655
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1656 1657 1658
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1659
	int skip_sum;
1660
	int metadata = 0;
1661
	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1662

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

1665
	if (btrfs_is_free_space_inode(inode))
1666 1667
		metadata = 2;

1668
	if (!(rw & REQ_WRITE)) {
1669 1670
		ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
		if (ret)
1671
			goto out;
1672

1673
		if (bio_flags & EXTENT_BIO_COMPRESSED) {
1674 1675 1676 1677
			ret = btrfs_submit_compressed_read(inode, bio,
							   mirror_num,
							   bio_flags);
			goto out;
1678 1679 1680
		} else if (!skip_sum) {
			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
			if (ret)
1681
				goto out;
1682
		}
1683
		goto mapit;
1684
	} else if (async && !skip_sum) {
1685 1686 1687
		/* csum items have already been cloned */
		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
			goto mapit;
1688
		/* we're doing a write, do the async checksumming */
1689
		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1690
				   inode, rw, bio, mirror_num,
1691 1692
				   bio_flags, bio_offset,
				   __btrfs_submit_bio_start,
C
Chris Mason 已提交
1693
				   __btrfs_submit_bio_done);
1694
		goto out;
1695 1696 1697 1698
	} else if (!skip_sum) {
		ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
		if (ret)
			goto out;
1699 1700
	}

1701
mapit:
1702 1703 1704 1705 1706 1707
	ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);

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

C
Chris Mason 已提交
1710 1711 1712 1713
/*
 * 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.
 */
1714
static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1715 1716 1717 1718 1719
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

Q
Qinghuang Feng 已提交
1720
	list_for_each_entry(sum, list, list) {
M
Miao Xie 已提交
1721
		trans->adding_csums = 1;
1722 1723
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
M
Miao Xie 已提交
1724
		trans->adding_csums = 0;
1725 1726 1727 1728
	}
	return 0;
}

1729 1730
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
			      struct extent_state **cached_state)
1731
{
J
Julia Lawall 已提交
1732
	WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1733
	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1734
				   cached_state, GFP_NOFS);
1735 1736
}

C
Chris Mason 已提交
1737
/* see btrfs_writepage_start_hook for details on why this is required */
1738 1739 1740 1741 1742
struct btrfs_writepage_fixup {
	struct page *page;
	struct btrfs_work work;
};

1743
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1744 1745 1746
{
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_ordered_extent *ordered;
1747
	struct extent_state *cached_state = NULL;
1748 1749 1750 1751
	struct page *page;
	struct inode *inode;
	u64 page_start;
	u64 page_end;
1752
	int ret;
1753 1754 1755

	fixup = container_of(work, struct btrfs_writepage_fixup, work);
	page = fixup->page;
C
Chris Mason 已提交
1756
again:
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
	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;

1767
	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1768
			 &cached_state);
C
Chris Mason 已提交
1769 1770

	/* already ordered? We're done */
1771
	if (PagePrivate2(page))
1772
		goto out;
C
Chris Mason 已提交
1773 1774 1775

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
1776 1777
		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
				     page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
1778 1779
		unlock_page(page);
		btrfs_start_ordered_extent(inode, ordered, 1);
1780
		btrfs_put_ordered_extent(ordered);
C
Chris Mason 已提交
1781 1782
		goto again;
	}
1783

1784 1785 1786 1787 1788 1789 1790 1791
	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;
	 }

1792
	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1793
	ClearPageChecked(page);
1794
	set_page_dirty(page);
1795
out:
1796 1797
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
			     &cached_state, GFP_NOFS);
1798 1799 1800
out_page:
	unlock_page(page);
	page_cache_release(page);
1801
	kfree(fixup);
1802 1803 1804 1805 1806 1807 1808 1809
}

/*
 * 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 已提交
1810
 * In our case any range that doesn't have the ORDERED bit set
1811 1812 1813 1814
 * 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.
 */
1815
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1816 1817 1818 1819 1820
{
	struct inode *inode = page->mapping->host;
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_root *root = BTRFS_I(inode)->root;

1821 1822
	/* this page is properly in the ordered list */
	if (TestClearPagePrivate2(page))
1823 1824 1825 1826 1827 1828 1829 1830
		return 0;

	if (PageChecked(page))
		return -EAGAIN;

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

1832 1833 1834 1835 1836
	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);
1837
	return -EBUSY;
1838 1839
}

Y
Yan Zheng 已提交
1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
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();
1855 1856
	if (!path)
		return -ENOMEM;
Y
Yan Zheng 已提交
1857

1858
	path->leave_spinning = 1;
C
Chris Mason 已提交
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868

	/*
	 * 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 已提交
1869
	ret = btrfs_drop_extents(trans, root, inode, file_pos,
1870
				 file_pos + num_bytes, 0);
1871 1872
	if (ret)
		goto out;
Y
Yan Zheng 已提交
1873

L
Li Zefan 已提交
1874
	ins.objectid = btrfs_ino(inode);
Y
Yan Zheng 已提交
1875 1876 1877
	ins.offset = file_pos;
	ins.type = BTRFS_EXTENT_DATA_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1878 1879
	if (ret)
		goto out;
Y
Yan Zheng 已提交
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892
	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);
1893

Y
Yan Zheng 已提交
1894
	btrfs_mark_buffer_dirty(leaf);
1895
	btrfs_release_path(path);
Y
Yan Zheng 已提交
1896 1897 1898 1899 1900 1901

	inode_add_bytes(inode, num_bytes);

	ins.objectid = disk_bytenr;
	ins.offset = disk_num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
1902 1903
	ret = btrfs_alloc_reserved_file_extent(trans, root,
					root->root_key.objectid,
L
Li Zefan 已提交
1904
					btrfs_ino(inode), file_pos, &ins);
1905
out:
Y
Yan Zheng 已提交
1906
	btrfs_free_path(path);
1907

1908
	return ret;
Y
Yan Zheng 已提交
1909 1910
}

L
Liu Bo 已提交
1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 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
/* 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;
	}
2054
	ret = 0;
L
Liu Bo 已提交
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

	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;

2089 2090 2091 2092 2093 2094
		/*
		 * 'offset' refers to the exact key.offset,
		 * NOT the 'offset' field in btrfs_extent_data_ref, ie.
		 * (key.offset - extent_offset).
		 */
		if (key.offset != offset)
L
Liu Bo 已提交
2095 2096
			continue;

2097
		extent_offset = btrfs_file_extent_offset(leaf, extent);
L
Liu Bo 已提交
2098
		num_bytes = btrfs_file_extent_num_bytes(leaf, extent);
2099

L
Liu Bo 已提交
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
		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;
2115
	backref->file_pos = offset;
L
Liu Bo 已提交
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
	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) {
2138 2139
		ret = iterate_inodes_from_logical(old->bytenr +
						  old->extent_offset, fs_info,
L
Liu Bo 已提交
2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
						  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,
2159
			      struct new_sa_defrag_extent *new)
L
Liu Bo 已提交
2160
{
2161
	if (btrfs_file_extent_disk_bytenr(leaf, fi) != new->bytenr)
L
Liu Bo 已提交
2162 2163 2164 2165 2166
		return 0;

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

2167 2168 2169 2170
	if (btrfs_file_extent_compression(leaf, fi) != new->compress_type)
		return 0;

	if (btrfs_file_extent_encryption(leaf, fi) ||
L
Liu Bo 已提交
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
	    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;

2296
	path->leave_spinning = 1;
L
Liu Bo 已提交
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
	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);

2314 2315
		if (extent_len + found_key.offset == start &&
		    relink_is_mergable(leaf, fi, new)) {
L
Liu Bo 已提交
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
			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);
2353
	btrfs_release_path(path);
L
Liu Bo 已提交
2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366

	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);
2367
	path->leave_spinning = 0;
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 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 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
	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;
}

2552 2553 2554 2555 2556 2557
/*
 * 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 已提交
2558 2559 2560 2561
/* 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.
 */
2562
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2563
{
2564
	struct inode *inode = ordered_extent->inode;
2565
	struct btrfs_root *root = BTRFS_I(inode)->root;
2566
	struct btrfs_trans_handle *trans = NULL;
2567
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2568
	struct extent_state *cached_state = NULL;
L
Liu Bo 已提交
2569
	struct new_sa_defrag_extent *new = NULL;
2570
	int compress_type = 0;
2571 2572
	int ret = 0;
	u64 logical_len = ordered_extent->len;
2573
	bool nolock;
2574
	bool truncated = false;
2575

2576
	nolock = btrfs_is_free_space_inode(inode);
J
Josef Bacik 已提交
2577

2578 2579 2580 2581 2582
	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
		ret = -EIO;
		goto out;
	}

2583 2584 2585 2586 2587 2588 2589 2590
	if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags)) {
		truncated = true;
		logical_len = ordered_extent->truncated_len;
		/* Truncated the entire extent, don't bother adding */
		if (!logical_len)
			goto out;
	}

2591
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
2592
		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
2593 2594 2595 2596 2597 2598 2599 2600 2601
		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;
2602
		}
2603 2604 2605 2606
		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);
2607 2608
		goto out;
	}
2609

2610 2611
	lock_extent_bits(io_tree, ordered_extent->file_offset,
			 ordered_extent->file_offset + ordered_extent->len - 1,
2612
			 0, &cached_state);
2613

L
Liu Bo 已提交
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
	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 已提交
2628
	if (nolock)
2629
		trans = btrfs_join_transaction_nolock(root);
J
Josef Bacik 已提交
2630
	else
2631
		trans = btrfs_join_transaction(root);
2632 2633 2634 2635 2636
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		trans = NULL;
		goto out_unlock;
	}
2637
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2638

C
Chris Mason 已提交
2639
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
2640
		compress_type = ordered_extent->compress_type;
Y
Yan Zheng 已提交
2641
	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
2642
		BUG_ON(compress_type);
Y
Yan, Zheng 已提交
2643
		ret = btrfs_mark_extent_written(trans, inode,
Y
Yan Zheng 已提交
2644 2645
						ordered_extent->file_offset,
						ordered_extent->file_offset +
2646
						logical_len);
Y
Yan Zheng 已提交
2647
	} else {
2648
		BUG_ON(root == root->fs_info->tree_root);
Y
Yan Zheng 已提交
2649 2650 2651 2652
		ret = insert_reserved_file_extent(trans, inode,
						ordered_extent->file_offset,
						ordered_extent->start,
						ordered_extent->disk_len,
2653
						logical_len, logical_len,
2654
						compress_type, 0, 0,
Y
Yan Zheng 已提交
2655 2656
						BTRFS_FILE_EXTENT_REG);
	}
J
Josef Bacik 已提交
2657 2658 2659
	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
			   ordered_extent->file_offset, ordered_extent->len,
			   trans->transid);
2660 2661
	if (ret < 0) {
		btrfs_abort_transaction(trans, root, ret);
2662
		goto out_unlock;
2663
	}
2664

2665 2666 2667
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

2668 2669 2670 2671 2672
	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;
2673 2674
	}
	ret = 0;
2675 2676 2677 2678
out_unlock:
	unlock_extent_cached(io_tree, ordered_extent->file_offset,
			     ordered_extent->file_offset +
			     ordered_extent->len - 1, &cached_state, GFP_NOFS);
2679
out:
2680
	if (root != root->fs_info->tree_root)
J
Josef Bacik 已提交
2681
		btrfs_delalloc_release_metadata(inode, ordered_extent->len);
2682 2683
	if (trans)
		btrfs_end_transaction(trans, root);
J
Josef Bacik 已提交
2684

2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
	if (ret || truncated) {
		u64 start, end;

		if (truncated)
			start = ordered_extent->file_offset + logical_len;
		else
			start = ordered_extent->file_offset;
		end = ordered_extent->file_offset + ordered_extent->len - 1;
		clear_extent_uptodate(io_tree, start, end, NULL, GFP_NOFS);

		/* Drop the cache for the part of the extent we didn't write. */
		btrfs_drop_extent_cache(inode, start, end, 0);
2697

2698 2699 2700
		/*
		 * If the ordered extent had an IOERR or something else went
		 * wrong we need to return the space for this ordered extent
2701 2702
		 * back to the allocator.  We only free the extent in the
		 * truncated case if we didn't write out the extent at all.
2703
		 */
2704 2705
		if ((ret || !logical_len) &&
		    !test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
2706 2707 2708 2709 2710 2711
		    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags))
			btrfs_free_reserved_extent(root, ordered_extent->start,
						   ordered_extent->disk_len);
	}


2712
	/*
2713 2714
	 * This needs to be done to make sure anybody waiting knows we are done
	 * updating everything for this ordered extent.
2715 2716 2717
	 */
	btrfs_remove_ordered_extent(inode, ordered_extent);

L
Liu Bo 已提交
2718 2719 2720 2721
	/* for snapshot-aware defrag */
	if (new)
		relink_file_extents(new);

2722 2723 2724 2725 2726
	/* once for us */
	btrfs_put_ordered_extent(ordered_extent);
	/* once for the tree */
	btrfs_put_ordered_extent(ordered_extent);

2727 2728 2729 2730 2731 2732 2733 2734
	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);
2735 2736
}

2737
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2738 2739
				struct extent_state *state, int uptodate)
{
2740 2741 2742 2743 2744
	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;

2745 2746
	trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);

2747
	ClearPagePrivate2(page);
2748 2749 2750 2751 2752 2753 2754
	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;

2755
	if (btrfs_is_free_space_inode(inode))
2756 2757 2758 2759 2760 2761
		workers = &root->fs_info->endio_freespace_worker;
	else
		workers = &root->fs_info->endio_write_workers;
	btrfs_queue_worker(workers, &ordered_extent->work);

	return 0;
2762 2763
}

C
Chris Mason 已提交
2764 2765
/*
 * when reads are done, we need to check csums to verify the data is correct
2766 2767
 * 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 已提交
2768
 */
2769 2770 2771
static int btrfs_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
				      u64 phy_offset, struct page *page,
				      u64 start, u64 end, int mirror)
2772
{
M
Miao Xie 已提交
2773
	size_t offset = start - page_offset(page);
2774
	struct inode *inode = page->mapping->host;
2775
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2776
	char *kaddr;
2777
	struct btrfs_root *root = BTRFS_I(inode)->root;
2778
	u32 csum_expected;
2779
	u32 csum = ~(u32)0;
2780 2781
	static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
	                              DEFAULT_RATELIMIT_BURST);
2782

2783 2784 2785 2786
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
2787 2788

	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
2789
		goto good;
2790 2791

	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
2792
	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
2793 2794
		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
				  GFP_NOFS);
2795
		return 0;
2796
	}
2797

2798 2799
	phy_offset >>= inode->i_sb->s_blocksize_bits;
	csum_expected = *(((u32 *)io_bio->csum) + phy_offset);
C
Chris Mason 已提交
2800

2801
	kaddr = kmap_atomic(page);
2802
	csum = btrfs_csum_data(kaddr + offset, csum,  end - start + 1);
2803
	btrfs_csum_final(csum, (char *)&csum);
2804
	if (csum != csum_expected)
2805
		goto zeroit;
C
Chris Mason 已提交
2806

2807
	kunmap_atomic(kaddr);
2808
good:
2809 2810 2811
	return 0;

zeroit:
2812
	if (__ratelimit(&_rs))
2813
		btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
2814
			btrfs_ino(page->mapping->host), start, csum, csum_expected);
2815 2816
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
2817
	kunmap_atomic(kaddr);
2818
	if (csum_expected == 0)
2819
		return 0;
2820
	return -EIO;
2821
}
2822

Y
Yan, Zheng 已提交
2823 2824 2825 2826 2827
struct delayed_iput {
	struct list_head list;
	struct inode *inode;
};

2828 2829
/* JDM: If this is fs-wide, why can't we add a pointer to
 * btrfs_inode instead and avoid the allocation? */
Y
Yan, Zheng 已提交
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870
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);
	}
}

2871
/*
2872
 * This is called in transaction commit time. If there are no orphan
2873 2874 2875 2876 2877 2878
 * 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)
{
2879
	struct btrfs_block_rsv *block_rsv;
2880 2881
	int ret;

2882
	if (atomic_read(&root->orphan_inodes) ||
2883 2884 2885
	    root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
		return;

2886
	spin_lock(&root->orphan_lock);
2887
	if (atomic_read(&root->orphan_inodes)) {
2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
		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);

2901 2902 2903 2904
	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);
2905 2906 2907 2908
		if (ret)
			btrfs_abort_transaction(trans, root, ret);
		else
			root->orphan_item_inserted = 0;
2909 2910
	}

2911 2912 2913
	if (block_rsv) {
		WARN_ON(block_rsv->size > 0);
		btrfs_free_block_rsv(root, block_rsv);
2914 2915 2916
	}
}

2917 2918 2919
/*
 * This creates an orphan entry for the given inode in case something goes
 * wrong in the middle of an unlink/truncate.
2920 2921 2922
 *
 * NOTE: caller of this function should reserve 5 units of metadata for
 *	 this function.
2923 2924 2925 2926
 */
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
2927 2928 2929 2930
	struct btrfs_block_rsv *block_rsv = NULL;
	int reserve = 0;
	int insert = 0;
	int ret;
2931

2932
	if (!root->orphan_block_rsv) {
2933
		block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
2934 2935
		if (!block_rsv)
			return -ENOMEM;
2936
	}
2937

2938 2939 2940 2941 2942 2943
	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;
2944 2945
	}

2946 2947
	if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			      &BTRFS_I(inode)->runtime_flags)) {
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
#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;
2960
		atomic_inc(&root->orphan_inodes);
2961 2962
	}

2963 2964
	if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			      &BTRFS_I(inode)->runtime_flags))
2965 2966
		reserve = 1;
	spin_unlock(&root->orphan_lock);
2967

2968 2969 2970
	/* grab metadata reservation from transaction handle */
	if (reserve) {
		ret = btrfs_orphan_reserve_metadata(trans, inode);
2971
		BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */
2972
	}
2973

2974 2975
	/* insert an orphan item to track this unlinked/truncated file */
	if (insert >= 1) {
L
Li Zefan 已提交
2976
		ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
2977
		if (ret) {
2978
			atomic_dec(&root->orphan_inodes);
2979 2980 2981 2982 2983 2984
			if (reserve) {
				clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
					  &BTRFS_I(inode)->runtime_flags);
				btrfs_orphan_release_metadata(inode);
			}
			if (ret != -EEXIST) {
2985 2986
				clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
					  &BTRFS_I(inode)->runtime_flags);
2987 2988 2989
				btrfs_abort_transaction(trans, root, ret);
				return ret;
			}
2990 2991
		}
		ret = 0;
2992 2993 2994 2995 2996 2997
	}

	/* 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);
2998 2999 3000 3001
		if (ret && ret != -EEXIST) {
			btrfs_abort_transaction(trans, root, ret);
			return ret;
		}
3002 3003
	}
	return 0;
3004 3005 3006 3007 3008 3009
}

/*
 * We have done the truncate/delete so we can go ahead and remove the orphan
 * item for this particular inode.
 */
3010 3011
static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
			    struct inode *inode)
3012 3013
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
3014 3015
	int delete_item = 0;
	int release_rsv = 0;
3016 3017
	int ret = 0;

3018
	spin_lock(&root->orphan_lock);
3019 3020
	if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			       &BTRFS_I(inode)->runtime_flags))
3021
		delete_item = 1;
3022

3023 3024
	if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			       &BTRFS_I(inode)->runtime_flags))
3025 3026
		release_rsv = 1;
	spin_unlock(&root->orphan_lock);
3027

3028
	if (delete_item) {
3029
		atomic_dec(&root->orphan_inodes);
3030 3031 3032
		if (trans)
			ret = btrfs_del_orphan_item(trans, root,
						    btrfs_ino(inode));
3033
	}
3034

3035 3036 3037
	if (release_rsv)
		btrfs_orphan_release_metadata(inode);

3038
	return ret;
3039 3040 3041 3042 3043 3044
}

/*
 * this cleans up any orphans that may be left on the list from the last use
 * of this root.
 */
3045
int btrfs_orphan_cleanup(struct btrfs_root *root)
3046 3047 3048 3049 3050 3051
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key, found_key;
	struct btrfs_trans_handle *trans;
	struct inode *inode;
3052
	u64 last_objectid = 0;
3053 3054
	int ret = 0, nr_unlink = 0, nr_truncate = 0;

3055
	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
3056
		return 0;
3057 3058

	path = btrfs_alloc_path();
3059 3060 3061 3062
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}
3063 3064 3065 3066 3067 3068 3069 3070
	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);
3071 3072
		if (ret < 0)
			goto out;
3073 3074 3075

		/*
		 * if ret == 0 means we found what we were searching for, which
L
Lucas De Marchi 已提交
3076
		 * is weird, but possible, so only screw with path if we didn't
3077 3078 3079
		 * find the key and see if we have stuff that matches
		 */
		if (ret > 0) {
3080
			ret = 0;
3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
			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 */
3097
		btrfs_release_path(path);
3098 3099 3100 3101 3102 3103

		/*
		 * 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.
		 */
3104 3105

		if (found_key.offset == last_objectid) {
3106 3107
			btrfs_err(root->fs_info,
				"Error removing orphan entry, stopping orphan cleanup");
3108 3109 3110 3111 3112 3113
			ret = -EINVAL;
			goto out;
		}

		last_objectid = found_key.offset;

3114 3115 3116
		found_key.objectid = found_key.offset;
		found_key.type = BTRFS_INODE_ITEM_KEY;
		found_key.offset = 0;
3117
		inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
3118
		ret = PTR_ERR_OR_ZERO(inode);
J
Josef Bacik 已提交
3119
		if (ret && ret != -ESTALE)
3120
			goto out;
3121

3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153
		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;
			}
		}
3154
		/*
J
Josef Bacik 已提交
3155 3156
		 * Inode is already gone but the orphan item is still there,
		 * kill the orphan item.
3157
		 */
J
Josef Bacik 已提交
3158 3159
		if (ret == -ESTALE) {
			trans = btrfs_start_transaction(root, 1);
3160 3161 3162 3163
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				goto out;
			}
3164 3165
			btrfs_debug(root->fs_info, "auto deleting %Lu",
				found_key.objectid);
J
Josef Bacik 已提交
3166 3167
			ret = btrfs_del_orphan_item(trans, root,
						    found_key.objectid);
3168
			btrfs_end_transaction(trans, root);
3169 3170
			if (ret)
				goto out;
3171 3172 3173
			continue;
		}

J
Josef Bacik 已提交
3174 3175 3176 3177
		/*
		 * add this inode to the orphan list so btrfs_orphan_del does
		 * the proper thing when we hit it
		 */
3178 3179
		set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			&BTRFS_I(inode)->runtime_flags);
3180
		atomic_inc(&root->orphan_inodes);
J
Josef Bacik 已提交
3181

3182 3183
		/* if we have links, this was a truncate, lets do that */
		if (inode->i_nlink) {
3184 3185 3186 3187 3188
			if (!S_ISREG(inode->i_mode)) {
				WARN_ON(1);
				iput(inode);
				continue;
			}
3189
			nr_truncate++;
3190 3191 3192 3193

			/* 1 for the orphan item deletion. */
			trans = btrfs_start_transaction(root, 1);
			if (IS_ERR(trans)) {
3194
				iput(inode);
3195 3196 3197 3198 3199
				ret = PTR_ERR(trans);
				goto out;
			}
			ret = btrfs_orphan_add(trans, inode);
			btrfs_end_transaction(trans, root);
3200 3201
			if (ret) {
				iput(inode);
3202
				goto out;
3203
			}
3204

3205
			ret = btrfs_truncate(inode);
3206 3207
			if (ret)
				btrfs_orphan_del(NULL, inode);
3208 3209 3210 3211 3212 3213
		} else {
			nr_unlink++;
		}

		/* this will do delete_inode and everything for us */
		iput(inode);
3214 3215
		if (ret)
			goto out;
3216
	}
3217 3218 3219
	/* release the path since we're done with it */
	btrfs_release_path(path);

3220 3221 3222 3223 3224 3225 3226
	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) {
3227
		trans = btrfs_join_transaction(root);
3228 3229
		if (!IS_ERR(trans))
			btrfs_end_transaction(trans, root);
3230
	}
3231 3232

	if (nr_unlink)
3233
		btrfs_debug(root->fs_info, "unlinked %d orphans", nr_unlink);
3234
	if (nr_truncate)
3235
		btrfs_debug(root->fs_info, "truncated %d orphans", nr_truncate);
3236 3237 3238

out:
	if (ret)
3239 3240
		btrfs_crit(root->fs_info,
			"could not do orphan cleanup %d", ret);
3241 3242
	btrfs_free_path(path);
	return ret;
3243 3244
}

3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255
/*
 * 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;
3256 3257
	static u64 xattr_access = 0;
	static u64 xattr_default = 0;
3258 3259
	int scanned = 0;

3260 3261 3262 3263 3264 3265 3266
	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));
	}

3267 3268 3269 3270 3271 3272 3273 3274 3275
	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 */
3276 3277 3278 3279 3280
		if (found_key.type == BTRFS_XATTR_ITEM_KEY) {
			if (found_key.offset == xattr_access ||
			    found_key.offset == xattr_default)
				return 1;
		}
3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307

		/*
		 * 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 已提交
3308 3309 3310
/*
 * read an inode from the btree into the in-memory inode
 */
3311
static void btrfs_read_locked_inode(struct inode *inode)
C
Chris Mason 已提交
3312 3313
{
	struct btrfs_path *path;
3314
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3315
	struct btrfs_inode_item *inode_item;
3316
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
3317 3318
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
3319
	int maybe_acls;
J
Josef Bacik 已提交
3320
	u32 rdev;
C
Chris Mason 已提交
3321
	int ret;
3322 3323 3324 3325 3326
	bool filled = false;

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

	path = btrfs_alloc_path();
3329 3330 3331
	if (!path)
		goto make_bad;

3332
	path->leave_spinning = 1;
C
Chris Mason 已提交
3333
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
C
Chris Mason 已提交
3334

C
Chris Mason 已提交
3335
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
3336
	if (ret)
C
Chris Mason 已提交
3337 3338
		goto make_bad;

3339
	leaf = path->nodes[0];
3340 3341 3342 3343

	if (filled)
		goto cache_acl;

3344 3345 3346
	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 已提交
3347
	set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
3348 3349
	i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
	i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
3350
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363

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

3364
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
3365
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
J
Josef Bacik 已提交
3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377
	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);

3378
	inode->i_version = btrfs_inode_sequence(leaf, inode_item);
3379
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
3380
	inode->i_rdev = 0;
3381 3382
	rdev = btrfs_inode_rdev(leaf, inode_item);

3383
	BTRFS_I(inode)->index_cnt = (u64)-1;
3384
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
3385
cache_acl:
3386 3387 3388 3389
	/*
	 * try to precache a NULL acl entry for files that don't have
	 * any xattrs or acls
	 */
L
Li Zefan 已提交
3390 3391
	maybe_acls = acls_after_inode_item(leaf, path->slots[0],
					   btrfs_ino(inode));
3392 3393
	if (!maybe_acls)
		cache_no_acl(inode);
3394

C
Chris Mason 已提交
3395 3396 3397 3398 3399
	btrfs_free_path(path);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
3400
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3401
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
		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 已提交
3415
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
3416
		break;
J
Josef Bacik 已提交
3417
	default:
J
Jim Owens 已提交
3418
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
3419 3420
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
3421
	}
3422 3423

	btrfs_update_iflags(inode);
C
Chris Mason 已提交
3424 3425 3426 3427 3428 3429 3430
	return;

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

C
Chris Mason 已提交
3431 3432 3433
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
3434 3435
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
3436
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
3437 3438
			    struct inode *inode)
{
3439 3440 3441
	struct btrfs_map_token token;

	btrfs_init_map_token(&token);
3442

3443 3444 3445 3446 3447 3448
	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);
3449

3450 3451 3452 3453
	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);
3454

3455 3456 3457 3458
	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);
3459

3460 3461 3462 3463
	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);
3464

3465 3466 3467 3468 3469 3470 3471 3472 3473
	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 已提交
3474 3475
}

C
Chris Mason 已提交
3476 3477 3478
/*
 * copy everything in the in-memory inode into the btree.
 */
3479
static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
3480
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
3481 3482 3483
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
3484
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3485 3486 3487
	int ret;

	path = btrfs_alloc_path();
3488 3489 3490
	if (!path)
		return -ENOMEM;

3491
	path->leave_spinning = 1;
3492 3493
	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
				 1);
C
Chris Mason 已提交
3494 3495 3496 3497 3498 3499
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

3500
	btrfs_unlock_up_safe(path, 1);
3501 3502
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
3503
				    struct btrfs_inode_item);
C
Chris Mason 已提交
3504

3505
	fill_inode_item(trans, leaf, inode_item, inode);
3506
	btrfs_mark_buffer_dirty(leaf);
3507
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
3508 3509 3510 3511 3512 3513
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}

3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
/*
 * 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
	 */
3529
	if (!btrfs_is_free_space_inode(inode)
3530
	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
3531 3532
		btrfs_update_root_times(trans, root);

3533 3534 3535 3536 3537 3538 3539 3540 3541
		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);
}

3542 3543 3544
noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root,
					 struct inode *inode)
3545 3546 3547 3548 3549 3550 3551 3552 3553
{
	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 已提交
3554 3555 3556 3557 3558
/*
 * 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
 */
3559 3560 3561 3562
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 已提交
3563 3564 3565
{
	struct btrfs_path *path;
	int ret = 0;
3566
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3567
	struct btrfs_dir_item *di;
3568
	struct btrfs_key key;
3569
	u64 index;
L
Li Zefan 已提交
3570 3571
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
C
Chris Mason 已提交
3572 3573

	path = btrfs_alloc_path();
3574 3575
	if (!path) {
		ret = -ENOMEM;
3576
		goto out;
3577 3578
	}

3579
	path->leave_spinning = 1;
L
Li Zefan 已提交
3580
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
C
Chris Mason 已提交
3581 3582 3583 3584 3585 3586 3587 3588 3589
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
3590 3591
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
3592
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
3593 3594
	if (ret)
		goto err;
3595
	btrfs_release_path(path);
C
Chris Mason 已提交
3596

L
Li Zefan 已提交
3597 3598
	ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
				  dir_ino, &index);
3599
	if (ret) {
3600 3601
		btrfs_info(root->fs_info,
			"failed to delete reference to %.*s, inode %llu parent %llu",
3602
			name_len, name, ino, dir_ino);
3603
		btrfs_abort_transaction(trans, root, ret);
3604 3605 3606
		goto err;
	}

3607
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3608 3609
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
3610
		goto err;
3611
	}
C
Chris Mason 已提交
3612

3613
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
L
Li Zefan 已提交
3614
					 inode, dir_ino);
3615 3616 3617 3618
	if (ret != 0 && ret != -ENOENT) {
		btrfs_abort_transaction(trans, root, ret);
		goto err;
	}
3619 3620 3621

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
3622 3623
	if (ret == -ENOENT)
		ret = 0;
3624 3625
	else if (ret)
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
3626 3627
err:
	btrfs_free_path(path);
3628 3629 3630 3631
	if (ret)
		goto out;

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3632 3633
	inode_inc_iversion(inode);
	inode_inc_iversion(dir);
3634
	inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3635
	ret = btrfs_update_inode(trans, root, dir);
3636
out:
C
Chris Mason 已提交
3637 3638 3639
	return ret;
}

3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652
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 已提交
3653

3654 3655 3656
/*
 * helper to start transaction for unlink and rmdir.
 *
3657 3658 3659 3660
 * 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.
3661
 */
3662
static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir)
3663
{
C
Chris Mason 已提交
3664
	struct btrfs_trans_handle *trans;
3665
	struct btrfs_root *root = BTRFS_I(dir)->root;
3666 3667
	int ret;

3668 3669 3670 3671 3672 3673 3674
	/*
	 * 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
	 */
3675
	trans = btrfs_start_transaction(root, 5);
3676 3677
	if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
		return trans;
3678

3679 3680
	if (PTR_ERR(trans) == -ENOSPC) {
		u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
3681

3682 3683 3684 3685 3686 3687 3688 3689 3690
		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);
3691
		}
3692
		trans->block_rsv = &root->fs_info->trans_block_rsv;
3693
		trans->bytes_reserved = num_bytes;
3694
	}
3695
	return trans;
3696 3697 3698 3699 3700 3701 3702 3703 3704
}

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;

3705
	trans = __unlink_start_trans(dir);
3706 3707
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3708

3709 3710
	btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);

3711 3712
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
3713 3714
	if (ret)
		goto out;
3715

3716
	if (inode->i_nlink == 0) {
3717
		ret = btrfs_orphan_add(trans, inode);
3718 3719
		if (ret)
			goto out;
3720
	}
3721

3722
out:
3723
	btrfs_end_transaction(trans, root);
3724
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
3725 3726 3727
	return ret;
}

3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738
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 已提交
3739
	u64 dir_ino = btrfs_ino(dir);
3740 3741 3742 3743 3744

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

L
Li Zefan 已提交
3745
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3746
				   name, name_len, -1);
3747 3748 3749 3750 3751 3752 3753
	if (IS_ERR_OR_NULL(di)) {
		if (!di)
			ret = -ENOENT;
		else
			ret = PTR_ERR(di);
		goto out;
	}
3754 3755 3756 3757 3758

	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);
3759 3760 3761 3762
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3763
	btrfs_release_path(path);
3764 3765 3766

	ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
				 objectid, root->root_key.objectid,
L
Li Zefan 已提交
3767
				 dir_ino, &index, name, name_len);
3768
	if (ret < 0) {
3769 3770 3771 3772
		if (ret != -ENOENT) {
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
L
Li Zefan 已提交
3773
		di = btrfs_search_dir_index_item(root, path, dir_ino,
3774
						 name, name_len);
3775 3776 3777 3778 3779 3780 3781 3782
		if (IS_ERR_OR_NULL(di)) {
			if (!di)
				ret = -ENOENT;
			else
				ret = PTR_ERR(di);
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
3783 3784 3785

		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3786
		btrfs_release_path(path);
3787 3788
		index = key.offset;
	}
3789
	btrfs_release_path(path);
3790

3791
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3792 3793 3794 3795
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3796 3797

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3798
	inode_inc_iversion(dir);
3799
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3800
	ret = btrfs_update_inode_fallback(trans, root, dir);
3801 3802 3803
	if (ret)
		btrfs_abort_transaction(trans, root, ret);
out:
3804
	btrfs_free_path(path);
3805
	return ret;
3806 3807
}

C
Chris Mason 已提交
3808 3809 3810
static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
3811
	int err = 0;
C
Chris Mason 已提交
3812 3813 3814
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;

3815
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
Y
Yan 已提交
3816
		return -ENOTEMPTY;
3817 3818
	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
		return -EPERM;
Y
Yan 已提交
3819

3820
	trans = __unlink_start_trans(dir);
3821
	if (IS_ERR(trans))
3822 3823
		return PTR_ERR(trans);

L
Li Zefan 已提交
3824
	if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
3825 3826 3827 3828 3829 3830 3831
		err = btrfs_unlink_subvol(trans, root, dir,
					  BTRFS_I(inode)->location.objectid,
					  dentry->d_name.name,
					  dentry->d_name.len);
		goto out;
	}

3832 3833
	err = btrfs_orphan_add(trans, inode);
	if (err)
3834
		goto out;
3835

C
Chris Mason 已提交
3836
	/* now the directory is empty */
3837 3838
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
C
Chris Mason 已提交
3839
	if (!err)
3840
		btrfs_i_size_write(inode, 0);
3841
out:
3842
	btrfs_end_transaction(trans, root);
3843
	btrfs_btree_balance_dirty(root);
3844

C
Chris Mason 已提交
3845 3846 3847 3848 3849 3850
	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 已提交
3851
 * any higher than new_size
C
Chris Mason 已提交
3852 3853 3854
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
3855 3856 3857
 *
 * 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 已提交
3858
 */
3859 3860 3861 3862
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 已提交
3863 3864
{
	struct btrfs_path *path;
3865
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3866
	struct btrfs_file_extent_item *fi;
3867 3868
	struct btrfs_key key;
	struct btrfs_key found_key;
C
Chris Mason 已提交
3869
	u64 extent_start = 0;
3870
	u64 extent_num_bytes = 0;
3871
	u64 extent_offset = 0;
C
Chris Mason 已提交
3872
	u64 item_end = 0;
3873
	u64 last_size = (u64)-1;
3874
	u32 found_type = (u8)-1;
C
Chris Mason 已提交
3875 3876
	int found_extent;
	int del_item;
3877 3878
	int pending_del_nr = 0;
	int pending_del_slot = 0;
3879
	int extent_type = -1;
3880 3881
	int ret;
	int err = 0;
L
Li Zefan 已提交
3882
	u64 ino = btrfs_ino(inode);
3883 3884

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

3886 3887 3888 3889 3890
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->reada = -1;

J
Josef Bacik 已提交
3891 3892 3893 3894 3895
	/*
	 * 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.
	 */
3896
	if (root->ref_cows || root == root->fs_info->tree_root)
3897 3898
		btrfs_drop_extent_cache(inode, ALIGN(new_size,
					root->sectorsize), (u64)-1, 0);
3899

3900 3901 3902 3903 3904 3905 3906 3907 3908
	/*
	 * 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 已提交
3909
	key.objectid = ino;
C
Chris Mason 已提交
3910
	key.offset = (u64)-1;
3911 3912
	key.type = (u8)-1;

3913
search_again:
3914
	path->leave_spinning = 1;
3915
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3916 3917 3918 3919
	if (ret < 0) {
		err = ret;
		goto out;
	}
C
Chris Mason 已提交
3920

3921
	if (ret > 0) {
3922 3923 3924
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
3925 3926
		if (path->slots[0] == 0)
			goto out;
3927 3928 3929
		path->slots[0]--;
	}

C
Chris Mason 已提交
3930
	while (1) {
C
Chris Mason 已提交
3931
		fi = NULL;
3932 3933 3934
		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 已提交
3935

L
Li Zefan 已提交
3936
		if (found_key.objectid != ino)
C
Chris Mason 已提交
3937
			break;
3938

3939
		if (found_type < min_type)
C
Chris Mason 已提交
3940 3941
			break;

3942
		item_end = found_key.offset;
C
Chris Mason 已提交
3943
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
3944
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
3945
					    struct btrfs_file_extent_item);
3946 3947
			extent_type = btrfs_file_extent_type(leaf, fi);
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3948
				item_end +=
3949
				    btrfs_file_extent_num_bytes(leaf, fi);
3950 3951
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
C
Chris Mason 已提交
3952
									 fi);
C
Chris Mason 已提交
3953
			}
3954
			item_end--;
C
Chris Mason 已提交
3955
		}
3956 3957 3958 3959
		if (found_type > min_type) {
			del_item = 1;
		} else {
			if (item_end < new_size)
3960
				break;
3961 3962 3963 3964
			if (found_key.offset >= new_size)
				del_item = 1;
			else
				del_item = 0;
C
Chris Mason 已提交
3965 3966 3967
		}
		found_extent = 0;
		/* FIXME, shrink the extent if the ref count is only 1 */
3968 3969 3970
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

3971 3972 3973 3974 3975
		if (del_item)
			last_size = found_key.offset;
		else
			last_size = new_size;

3976
		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
3977
			u64 num_dec;
3978
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
3979
			if (!del_item) {
3980 3981
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
3982 3983 3984
				extent_num_bytes = ALIGN(new_size -
						found_key.offset,
						root->sectorsize);
3985 3986 3987
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
C
Chris Mason 已提交
3988
					   extent_num_bytes);
3989
				if (root->ref_cows && extent_start != 0)
3990
					inode_sub_bytes(inode, num_dec);
3991
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
3992
			} else {
3993 3994 3995
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
3996 3997 3998
				extent_offset = found_key.offset -
					btrfs_file_extent_offset(leaf, fi);

C
Chris Mason 已提交
3999
				/* FIXME blocksize != 4096 */
C
Chris Mason 已提交
4000
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
4001 4002
				if (extent_start != 0) {
					found_extent = 1;
4003
					if (root->ref_cows)
4004
						inode_sub_bytes(inode, num_dec);
4005
				}
C
Chris Mason 已提交
4006
			}
C
Chris Mason 已提交
4007
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
4008 4009 4010 4011 4012 4013 4014 4015
			/*
			 * 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) {
4016 4017 4018
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
4019 4020
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
4021 4022 4023
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
4024
				btrfs_truncate_item(root, path, size, 1);
4025
			} else if (root->ref_cows) {
4026 4027
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
C
Chris Mason 已提交
4028
			}
C
Chris Mason 已提交
4029
		}
4030
delete:
C
Chris Mason 已提交
4031
		if (del_item) {
4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
			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 已提交
4042
				BUG();
4043
			}
C
Chris Mason 已提交
4044 4045 4046
		} else {
			break;
		}
4047 4048
		if (found_extent && (root->ref_cows ||
				     root == root->fs_info->tree_root)) {
4049
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
4050
			ret = btrfs_free_extent(trans, root, extent_start,
4051 4052
						extent_num_bytes, 0,
						btrfs_header_owner(leaf),
A
Arne Jansen 已提交
4053
						ino, extent_offset, 0);
C
Chris Mason 已提交
4054 4055
			BUG_ON(ret);
		}
4056

4057 4058 4059 4060 4061 4062 4063 4064 4065
		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);
4066 4067 4068 4069 4070
				if (ret) {
					btrfs_abort_transaction(trans,
								root, ret);
					goto error;
				}
4071 4072
				pending_del_nr = 0;
			}
4073
			btrfs_release_path(path);
4074
			goto search_again;
4075 4076
		} else {
			path->slots[0]--;
4077
		}
C
Chris Mason 已提交
4078
	}
4079
out:
4080 4081 4082
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
4083 4084
		if (ret)
			btrfs_abort_transaction(trans, root, ret);
4085
	}
4086
error:
4087 4088
	if (last_size != (u64)-1)
		btrfs_ordered_update_i_size(inode, last_size, NULL);
C
Chris Mason 已提交
4089
	btrfs_free_path(path);
4090
	return err;
C
Chris Mason 已提交
4091 4092 4093
}

/*
J
Josef Bacik 已提交
4094 4095 4096 4097 4098 4099 4100 4101 4102
 * 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 已提交
4103
 */
J
Josef Bacik 已提交
4104 4105
int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
			int front)
C
Chris Mason 已提交
4106
{
J
Josef Bacik 已提交
4107
	struct address_space *mapping = inode->i_mapping;
4108
	struct btrfs_root *root = BTRFS_I(inode)->root;
4109 4110
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
4111
	struct extent_state *cached_state = NULL;
4112
	char *kaddr;
4113
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
4114 4115 4116
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
4117
	gfp_t mask = btrfs_alloc_write_mask(mapping);
C
Chris Mason 已提交
4118
	int ret = 0;
4119
	u64 page_start;
4120
	u64 page_end;
C
Chris Mason 已提交
4121

J
Josef Bacik 已提交
4122 4123
	if ((offset & (blocksize - 1)) == 0 &&
	    (!len || ((len & (blocksize - 1)) == 0)))
C
Chris Mason 已提交
4124
		goto out;
4125
	ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
4126 4127
	if (ret)
		goto out;
C
Chris Mason 已提交
4128

4129
again:
4130
	page = find_or_create_page(mapping, index, mask);
4131
	if (!page) {
4132
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
4133
		ret = -ENOMEM;
C
Chris Mason 已提交
4134
		goto out;
4135
	}
4136 4137 4138 4139

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

C
Chris Mason 已提交
4140
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
4141
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
4142
		lock_page(page);
4143 4144 4145 4146 4147
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
4148 4149
		if (!PageUptodate(page)) {
			ret = -EIO;
4150
			goto out_unlock;
C
Chris Mason 已提交
4151 4152
		}
	}
4153
	wait_on_page_writeback(page);
4154

4155
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
4156 4157 4158 4159
	set_page_extent_mapped(page);

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
4160 4161
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
4162 4163
		unlock_page(page);
		page_cache_release(page);
4164
		btrfs_start_ordered_extent(inode, ordered, 1);
4165 4166 4167 4168
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

4169
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
4170 4171
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
4172
			  0, 0, &cached_state, GFP_NOFS);
4173

4174 4175
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
J
Josef Bacik 已提交
4176
	if (ret) {
4177 4178
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
4179 4180 4181
		goto out_unlock;
	}

4182
	if (offset != PAGE_CACHE_SIZE) {
J
Josef Bacik 已提交
4183 4184
		if (!len)
			len = PAGE_CACHE_SIZE - offset;
4185
		kaddr = kmap(page);
J
Josef Bacik 已提交
4186 4187 4188 4189
		if (front)
			memset(kaddr, 0, offset);
		else
			memset(kaddr + offset, 0, len);
4190 4191 4192
		flush_dcache_page(page);
		kunmap(page);
	}
4193
	ClearPageChecked(page);
4194
	set_page_dirty(page);
4195 4196
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
			     GFP_NOFS);
C
Chris Mason 已提交
4197

4198
out_unlock:
4199
	if (ret)
4200
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
4201 4202 4203 4204 4205 4206
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

4207 4208 4209 4210 4211 4212
/*
 * 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
 */
4213
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
C
Chris Mason 已提交
4214
{
Y
Yan Zheng 已提交
4215 4216 4217
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4218
	struct extent_map *em = NULL;
4219
	struct extent_state *cached_state = NULL;
J
Josef Bacik 已提交
4220
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4221 4222
	u64 hole_start = ALIGN(oldsize, root->sectorsize);
	u64 block_end = ALIGN(size, root->sectorsize);
Y
Yan Zheng 已提交
4223 4224 4225
	u64 last_byte;
	u64 cur_offset;
	u64 hole_size;
J
Josef Bacik 已提交
4226
	int err = 0;
C
Chris Mason 已提交
4227

4228 4229 4230 4231 4232 4233 4234 4235 4236
	/*
	 * 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 已提交
4237 4238 4239 4240 4241
	if (size <= hole_start)
		return 0;

	while (1) {
		struct btrfs_ordered_extent *ordered;
4242

4243
		lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
4244
				 &cached_state);
4245 4246
		ordered = btrfs_lookup_ordered_range(inode, hole_start,
						     block_end - hole_start);
Y
Yan Zheng 已提交
4247 4248
		if (!ordered)
			break;
4249 4250
		unlock_extent_cached(io_tree, hole_start, block_end - 1,
				     &cached_state, GFP_NOFS);
4251
		btrfs_start_ordered_extent(inode, ordered, 1);
Y
Yan Zheng 已提交
4252 4253
		btrfs_put_ordered_extent(ordered);
	}
C
Chris Mason 已提交
4254

Y
Yan Zheng 已提交
4255 4256 4257 4258
	cur_offset = hole_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				block_end - cur_offset, 0);
4259 4260
		if (IS_ERR(em)) {
			err = PTR_ERR(em);
4261
			em = NULL;
4262 4263
			break;
		}
Y
Yan Zheng 已提交
4264
		last_byte = min(extent_map_end(em), block_end);
4265
		last_byte = ALIGN(last_byte , root->sectorsize);
4266
		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
J
Josef Bacik 已提交
4267
			struct extent_map *hole_em;
Y
Yan Zheng 已提交
4268
			hole_size = last_byte - cur_offset;
J
Josef Bacik 已提交
4269

4270
			trans = btrfs_start_transaction(root, 3);
4271 4272
			if (IS_ERR(trans)) {
				err = PTR_ERR(trans);
J
Josef Bacik 已提交
4273
				break;
4274
			}
4275

J
Josef Bacik 已提交
4276 4277
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
4278
						 cur_offset + hole_size, 1);
4279
			if (err) {
4280
				btrfs_abort_transaction(trans, root, err);
4281
				btrfs_end_transaction(trans, root);
4282
				break;
4283
			}
4284

Y
Yan Zheng 已提交
4285
			err = btrfs_insert_file_extent(trans, root,
L
Li Zefan 已提交
4286
					btrfs_ino(inode), cur_offset, 0,
Y
Yan Zheng 已提交
4287 4288
					0, hole_size, 0, hole_size,
					0, 0, 0);
4289
			if (err) {
4290
				btrfs_abort_transaction(trans, root, err);
4291
				btrfs_end_transaction(trans, root);
4292
				break;
4293
			}
4294

J
Josef Bacik 已提交
4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305
			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;
4306

J
Josef Bacik 已提交
4307 4308
			hole_em->block_start = EXTENT_MAP_HOLE;
			hole_em->block_len = 0;
4309
			hole_em->orig_block_len = 0;
J
Josef Bacik 已提交
4310
			hole_em->ram_bytes = hole_size;
J
Josef Bacik 已提交
4311 4312 4313
			hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
			hole_em->compress_type = BTRFS_COMPRESS_NONE;
			hole_em->generation = trans->transid;
4314

J
Josef Bacik 已提交
4315 4316
			while (1) {
				write_lock(&em_tree->lock);
J
Josef Bacik 已提交
4317
				err = add_extent_mapping(em_tree, hole_em, 1);
J
Josef Bacik 已提交
4318 4319 4320 4321 4322 4323 4324 4325 4326
				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:
4327
			btrfs_update_inode(trans, root, inode);
4328
			btrfs_end_transaction(trans, root);
Y
Yan Zheng 已提交
4329 4330
		}
		free_extent_map(em);
4331
		em = NULL;
Y
Yan Zheng 已提交
4332
		cur_offset = last_byte;
4333
		if (cur_offset >= block_end)
Y
Yan Zheng 已提交
4334 4335
			break;
	}
4336

4337
	free_extent_map(em);
4338 4339
	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
			     GFP_NOFS);
Y
Yan Zheng 已提交
4340 4341
	return err;
}
C
Chris Mason 已提交
4342

4343
static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4344
{
4345 4346
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
4347
	loff_t oldsize = i_size_read(inode);
4348 4349
	loff_t newsize = attr->ia_size;
	int mask = attr->ia_valid;
4350 4351
	int ret;

4352 4353 4354 4355 4356 4357 4358 4359 4360
	/*
	 * 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);

4361
	if (newsize > oldsize) {
4362
		truncate_pagecache(inode, newsize);
4363
		ret = btrfs_cont_expand(inode, oldsize, newsize);
4364
		if (ret)
4365 4366
			return ret;

4367 4368 4369 4370 4371 4372 4373
		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);
4374
		btrfs_end_transaction(trans, root);
4375
	} else {
4376

4377 4378 4379 4380 4381 4382
		/*
		 * 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)
4383 4384
			set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
				&BTRFS_I(inode)->runtime_flags);
4385

4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
		/*
		 * 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;

4409 4410
		/* we don't support swapfiles, so vmtruncate shouldn't fail */
		truncate_setsize(inode, newsize);
4411 4412 4413 4414 4415 4416

		/* 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);

4417
		ret = btrfs_truncate(inode);
4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437
		if (ret && inode->i_nlink) {
			int err;

			/*
			 * failed to truncate, disk_i_size is only adjusted down
			 * as we remove extents, so it should represent the true
			 * size of the inode, so reset the in memory size and
			 * delete our orphan entry.
			 */
			trans = btrfs_join_transaction(root);
			if (IS_ERR(trans)) {
				btrfs_orphan_del(NULL, inode);
				return ret;
			}
			i_size_write(inode, BTRFS_I(inode)->disk_i_size);
			err = btrfs_orphan_del(trans, inode);
			if (err)
				btrfs_abort_transaction(trans, root, err);
			btrfs_end_transaction(trans, root);
		}
4438 4439
	}

4440
	return ret;
4441 4442
}

Y
Yan Zheng 已提交
4443 4444 4445
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
L
Li Zefan 已提交
4446
	struct btrfs_root *root = BTRFS_I(inode)->root;
Y
Yan Zheng 已提交
4447
	int err;
C
Chris Mason 已提交
4448

L
Li Zefan 已提交
4449 4450 4451
	if (btrfs_root_readonly(root))
		return -EROFS;

Y
Yan Zheng 已提交
4452 4453 4454
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
4455

4456
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
4457
		err = btrfs_setsize(inode, attr);
4458 4459
		if (err)
			return err;
C
Chris Mason 已提交
4460
	}
Y
Yan Zheng 已提交
4461

C
Christoph Hellwig 已提交
4462 4463
	if (attr->ia_valid) {
		setattr_copy(inode, attr);
4464
		inode_inc_iversion(inode);
4465
		err = btrfs_dirty_inode(inode);
C
Christoph Hellwig 已提交
4466

4467
		if (!err && attr->ia_valid & ATTR_MODE)
C
Christoph Hellwig 已提交
4468 4469
			err = btrfs_acl_chmod(inode);
	}
J
Josef Bacik 已提交
4470

C
Chris Mason 已提交
4471 4472
	return err;
}
4473

A
Al Viro 已提交
4474
void btrfs_evict_inode(struct inode *inode)
C
Chris Mason 已提交
4475 4476 4477
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
4478
	struct btrfs_block_rsv *rsv, *global_rsv;
4479
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
4480 4481
	int ret;

4482 4483
	trace_btrfs_inode_evict(inode);

C
Chris Mason 已提交
4484
	truncate_inode_pages(&inode->i_data, 0);
4485 4486 4487 4488
	if (inode->i_nlink &&
	    ((btrfs_root_refs(&root->root_item) != 0 &&
	      root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||
	     btrfs_is_free_space_inode(inode)))
A
Al Viro 已提交
4489 4490
		goto no_delete;

C
Chris Mason 已提交
4491
	if (is_bad_inode(inode)) {
4492
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
4493 4494
		goto no_delete;
	}
A
Al Viro 已提交
4495
	/* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
C
Chris Mason 已提交
4496
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
4497

4498
	if (root->fs_info->log_root_recovering) {
4499
		BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
4500
				 &BTRFS_I(inode)->runtime_flags));
4501 4502 4503
		goto no_delete;
	}

4504
	if (inode->i_nlink > 0) {
4505 4506
		BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&
		       root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID);
4507 4508 4509
		goto no_delete;
	}

4510 4511 4512 4513 4514 4515
	ret = btrfs_commit_inode_delayed_inode(inode);
	if (ret) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}

4516
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
4517 4518 4519 4520
	if (!rsv) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}
J
Josef Bacik 已提交
4521
	rsv->size = min_size;
4522
	rsv->failfast = 1;
4523
	global_rsv = &root->fs_info->global_block_rsv;
4524

4525
	btrfs_i_size_write(inode, 0);
4526

4527
	/*
4528 4529 4530 4531
	 * 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.
4532
	 */
4533
	while (1) {
M
Miao Xie 已提交
4534 4535
		ret = btrfs_block_rsv_refill(root, rsv, min_size,
					     BTRFS_RESERVE_FLUSH_LIMIT);
4536 4537 4538 4539 4540 4541 4542 4543

		/*
		 * 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);
4544 4545

		if (ret) {
4546 4547 4548
			btrfs_warn(root->fs_info,
				"Could not get space for a delete, will truncate on mount %d",
				ret);
4549 4550 4551
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
4552
		}
4553

4554
		trans = btrfs_join_transaction(root);
4555 4556 4557 4558
		if (IS_ERR(trans)) {
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
4559
		}
4560

4561 4562
		trans->block_rsv = rsv;

4563
		ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
4564
		if (ret != -ENOSPC)
4565
			break;
4566

4567
		trans->block_rsv = &root->fs_info->trans_block_rsv;
4568 4569
		btrfs_end_transaction(trans, root);
		trans = NULL;
4570
		btrfs_btree_balance_dirty(root);
4571
	}
4572

4573 4574
	btrfs_free_block_rsv(root, rsv);

4575 4576 4577 4578
	/*
	 * Errors here aren't a big deal, it just means we leave orphan items
	 * in the tree.  They will be cleaned up on the next mount.
	 */
4579
	if (ret == 0) {
4580
		trans->block_rsv = root->orphan_block_rsv;
4581 4582 4583
		btrfs_orphan_del(trans, inode);
	} else {
		btrfs_orphan_del(NULL, inode);
4584
	}
4585

4586
	trans->block_rsv = &root->fs_info->trans_block_rsv;
4587 4588
	if (!(root == root->fs_info->tree_root ||
	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
L
Li Zefan 已提交
4589
		btrfs_return_ino(root, btrfs_ino(inode));
4590

4591
	btrfs_end_transaction(trans, root);
4592
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
4593
no_delete:
4594
	btrfs_remove_delayed_node(inode);
4595
	clear_inode(inode);
4596
	return;
C
Chris Mason 已提交
4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
}

/*
 * 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 已提交
4611
	int ret = 0;
C
Chris Mason 已提交
4612 4613

	path = btrfs_alloc_path();
4614 4615
	if (!path)
		return -ENOMEM;
4616

L
Li Zefan 已提交
4617
	di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
C
Chris Mason 已提交
4618
				    namelen, 0);
Y
Yan 已提交
4619 4620
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
4621

4622
	if (IS_ERR_OR_NULL(di))
4623
		goto out_err;
C
Chris Mason 已提交
4624

4625
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
4626 4627 4628
out:
	btrfs_free_path(path);
	return ret;
4629 4630 4631
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
4632 4633 4634 4635 4636 4637 4638 4639
}

/*
 * 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,
4640 4641 4642 4643
				    struct inode *dir,
				    struct dentry *dentry,
				    struct btrfs_key *location,
				    struct btrfs_root **sub_root)
C
Chris Mason 已提交
4644
{
4645 4646 4647 4648 4649 4650
	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 已提交
4651

4652 4653 4654 4655 4656
	path = btrfs_alloc_path();
	if (!path) {
		err = -ENOMEM;
		goto out;
	}
C
Chris Mason 已提交
4657

4658 4659 4660 4661 4662 4663 4664 4665 4666
	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 已提交
4667

4668 4669
	leaf = path->nodes[0];
	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
L
Li Zefan 已提交
4670
	if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
4671 4672
	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
		goto out;
C
Chris Mason 已提交
4673

4674 4675 4676 4677 4678 4679
	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
				   (unsigned long)(ref + 1),
				   dentry->d_name.len);
	if (ret)
		goto out;

4680
	btrfs_release_path(path);
4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695

	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 已提交
4696 4697
}

4698 4699 4700 4701
static void inode_tree_add(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_inode *entry;
4702 4703
	struct rb_node **p;
	struct rb_node *parent;
4704
	struct rb_node *new = &BTRFS_I(inode)->rb_node;
L
Li Zefan 已提交
4705
	u64 ino = btrfs_ino(inode);
4706

A
Al Viro 已提交
4707
	if (inode_unhashed(inode))
4708
		return;
4709
	parent = NULL;
4710
	spin_lock(&root->inode_lock);
4711
	p = &root->inode_tree.rb_node;
4712 4713 4714 4715
	while (*p) {
		parent = *p;
		entry = rb_entry(parent, struct btrfs_inode, rb_node);

L
Li Zefan 已提交
4716
		if (ino < btrfs_ino(&entry->vfs_inode))
4717
			p = &parent->rb_left;
L
Li Zefan 已提交
4718
		else if (ino > btrfs_ino(&entry->vfs_inode))
4719
			p = &parent->rb_right;
4720 4721
		else {
			WARN_ON(!(entry->vfs_inode.i_state &
A
Al Viro 已提交
4722
				  (I_WILL_FREE | I_FREEING)));
4723
			rb_replace_node(parent, new, &root->inode_tree);
4724 4725
			RB_CLEAR_NODE(parent);
			spin_unlock(&root->inode_lock);
4726
			return;
4727 4728
		}
	}
4729 4730
	rb_link_node(new, parent, p);
	rb_insert_color(new, &root->inode_tree);
4731 4732 4733 4734 4735 4736
	spin_unlock(&root->inode_lock);
}

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

4739
	spin_lock(&root->inode_lock);
4740 4741 4742
	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);
4743
		empty = RB_EMPTY_ROOT(&root->inode_tree);
4744
	}
4745
	spin_unlock(&root->inode_lock);
4746

4747
	if (empty && btrfs_root_refs(&root->root_item) == 0) {
4748 4749 4750 4751 4752 4753 4754 4755 4756
		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);
	}
}

4757
void btrfs_invalidate_inodes(struct btrfs_root *root)
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774
{
	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 已提交
4775
		if (objectid < btrfs_ino(&entry->vfs_inode))
4776
			node = node->rb_left;
L
Li Zefan 已提交
4777
		else if (objectid > btrfs_ino(&entry->vfs_inode))
4778 4779 4780 4781 4782 4783 4784
			node = node->rb_right;
		else
			break;
	}
	if (!node) {
		while (prev) {
			entry = rb_entry(prev, struct btrfs_inode, rb_node);
L
Li Zefan 已提交
4785
			if (objectid <= btrfs_ino(&entry->vfs_inode)) {
4786 4787 4788 4789 4790 4791 4792 4793
				node = prev;
				break;
			}
			prev = rb_next(prev);
		}
	}
	while (node) {
		entry = rb_entry(node, struct btrfs_inode, rb_node);
L
Li Zefan 已提交
4794
		objectid = btrfs_ino(&entry->vfs_inode) + 1;
4795 4796 4797 4798 4799 4800
		inode = igrab(&entry->vfs_inode);
		if (inode) {
			spin_unlock(&root->inode_lock);
			if (atomic_read(&inode->i_count) > 1)
				d_prune_aliases(inode);
			/*
4801
			 * btrfs_drop_inode will have it removed from
4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816
			 * 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);
4817 4818
}

4819 4820 4821 4822 4823
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 已提交
4824 4825 4826 4827 4828 4829
	return 0;
}

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

4834 4835 4836
static struct inode *btrfs_iget_locked(struct super_block *s,
				       u64 objectid,
				       struct btrfs_root *root)
C
Chris Mason 已提交
4837 4838 4839
{
	struct inode *inode;
	struct btrfs_iget_args args;
4840 4841
	unsigned long hashval = btrfs_inode_hash(objectid, root);

C
Chris Mason 已提交
4842 4843 4844
	args.ino = objectid;
	args.root = root;

4845
	inode = iget5_locked(s, hashval, btrfs_find_actor,
C
Chris Mason 已提交
4846 4847 4848 4849 4850
			     btrfs_init_locked_inode,
			     (void *)&args);
	return inode;
}

B
Balaji Rao 已提交
4851 4852 4853 4854
/* 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,
4855
			 struct btrfs_root *root, int *new)
B
Balaji Rao 已提交
4856 4857 4858 4859 4860
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
4861
		return ERR_PTR(-ENOMEM);
B
Balaji Rao 已提交
4862 4863 4864 4865 4866

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
4867 4868 4869 4870 4871 4872
		if (!is_bad_inode(inode)) {
			inode_tree_add(inode);
			unlock_new_inode(inode);
			if (new)
				*new = 1;
		} else {
4873 4874 4875
			unlock_new_inode(inode);
			iput(inode);
			inode = ERR_PTR(-ESTALE);
4876 4877 4878
		}
	}

B
Balaji Rao 已提交
4879 4880 4881
	return inode;
}

4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892
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));
4893
	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
4894 4895

	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
L
Li Zefan 已提交
4896
	inode->i_op = &btrfs_dir_ro_inode_operations;
4897 4898 4899 4900 4901 4902 4903
	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;
}

4904
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
4905
{
C
Chris Mason 已提交
4906
	struct inode *inode;
4907
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
4908 4909
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
4910
	int index;
4911
	int ret = 0;
C
Chris Mason 已提交
4912 4913 4914

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

J
Jeff Layton 已提交
4916
	ret = btrfs_inode_by_name(dir, dentry, &location);
C
Chris Mason 已提交
4917 4918
	if (ret < 0)
		return ERR_PTR(ret);
4919

4920 4921 4922 4923
	if (location.objectid == 0)
		return NULL;

	if (location.type == BTRFS_INODE_ITEM_KEY) {
4924
		inode = btrfs_iget(dir->i_sb, &location, root, NULL);
4925 4926 4927 4928 4929
		return inode;
	}

	BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);

4930
	index = srcu_read_lock(&root->fs_info->subvol_srcu);
4931 4932 4933 4934 4935 4936 4937 4938
	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 {
4939
		inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
C
Chris Mason 已提交
4940
	}
4941 4942
	srcu_read_unlock(&root->fs_info->subvol_srcu, index);

4943
	if (!IS_ERR(inode) && root != sub_root) {
4944 4945
		down_read(&root->fs_info->cleanup_work_sem);
		if (!(inode->i_sb->s_flags & MS_RDONLY))
4946
			ret = btrfs_orphan_cleanup(sub_root);
4947
		up_read(&root->fs_info->cleanup_work_sem);
4948 4949
		if (ret) {
			iput(inode);
4950
			inode = ERR_PTR(ret);
4951
		}
4952 4953
	}

4954 4955 4956
	return inode;
}

N
Nick Piggin 已提交
4957
static int btrfs_dentry_delete(const struct dentry *dentry)
4958 4959
{
	struct btrfs_root *root;
L
Li Zefan 已提交
4960
	struct inode *inode = dentry->d_inode;
4961

L
Li Zefan 已提交
4962 4963
	if (!inode && !IS_ROOT(dentry))
		inode = dentry->d_parent->d_inode;
4964

L
Li Zefan 已提交
4965 4966
	if (inode) {
		root = BTRFS_I(inode)->root;
4967 4968
		if (btrfs_root_refs(&root->root_item) == 0)
			return 1;
L
Li Zefan 已提交
4969 4970 4971

		if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
			return 1;
4972
	}
4973 4974 4975
	return 0;
}

4976 4977 4978 4979 4980 4981
static void btrfs_dentry_release(struct dentry *dentry)
{
	if (dentry->d_fsdata)
		kfree(dentry->d_fsdata);
}

4982
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
4983
				   unsigned int flags)
4984
{
4985 4986 4987 4988
	struct dentry *ret;

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

4991
unsigned char btrfs_filetype_table[] = {
C
Chris Mason 已提交
4992 4993 4994
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

A
Al Viro 已提交
4995
static int btrfs_real_readdir(struct file *file, struct dir_context *ctx)
C
Chris Mason 已提交
4996
{
A
Al Viro 已提交
4997
	struct inode *inode = file_inode(file);
C
Chris Mason 已提交
4998 4999 5000 5001
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
5002
	struct btrfs_key found_key;
C
Chris Mason 已提交
5003
	struct btrfs_path *path;
5004 5005
	struct list_head ins_list;
	struct list_head del_list;
C
Chris Mason 已提交
5006
	int ret;
5007
	struct extent_buffer *leaf;
C
Chris Mason 已提交
5008 5009 5010 5011 5012 5013 5014
	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;
5015 5016 5017
	char tmp_name[32];
	char *name_ptr;
	int name_len;
A
Al Viro 已提交
5018
	int is_curr = 0;	/* ctx->pos points to the current index? */
C
Chris Mason 已提交
5019 5020 5021 5022

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

A
Al Viro 已提交
5024 5025 5026
	if (!dir_emit_dots(file, ctx))
		return 0;

5027
	path = btrfs_alloc_path();
5028 5029
	if (!path)
		return -ENOMEM;
C
Chris Mason 已提交
5030

J
Josef Bacik 已提交
5031
	path->reada = 1;
5032

5033 5034 5035 5036 5037 5038
	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 已提交
5039
	btrfs_set_key_type(&key, key_type);
A
Al Viro 已提交
5040
	key.offset = ctx->pos;
L
Li Zefan 已提交
5041
	key.objectid = btrfs_ino(inode);
5042

C
Chris Mason 已提交
5043 5044 5045
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
5046 5047

	while (1) {
5048
		leaf = path->nodes[0];
C
Chris Mason 已提交
5049
		slot = path->slots[0];
5050 5051 5052 5053 5054 5055 5056
		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 已提交
5057
		}
5058

5059
		item = btrfs_item_nr(slot);
5060 5061 5062
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
5063
			break;
5064
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
5065
			break;
A
Al Viro 已提交
5066
		if (found_key.offset < ctx->pos)
5067
			goto next;
5068 5069 5070 5071
		if (key_type == BTRFS_DIR_INDEX_KEY &&
		    btrfs_should_delete_dir_index(&del_list,
						  found_key.offset))
			goto next;
5072

A
Al Viro 已提交
5073
		ctx->pos = found_key.offset;
5074
		is_curr = 1;
5075

C
Chris Mason 已提交
5076 5077
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
5078
		di_total = btrfs_item_size(leaf, item);
5079 5080

		while (di_cur < di_total) {
5081 5082
			struct btrfs_key location;

5083 5084 5085
			if (verify_dir_item(root, leaf, di))
				break;

5086
			name_len = btrfs_dir_name_len(leaf, di);
5087
			if (name_len <= sizeof(tmp_name)) {
5088 5089 5090
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
5091 5092 5093 5094
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
5095 5096 5097 5098 5099 5100
			}
			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);
5101

5102

5103
			/* is this a reference to our own snapshot? If so
A
Arne Jansen 已提交
5104 5105 5106 5107 5108 5109 5110
			 * 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.
5111 5112 5113 5114 5115 5116
			 */
			if (location.type == BTRFS_ROOT_ITEM_KEY &&
			    location.objectid == root->root_key.objectid) {
				over = 0;
				goto skip;
			}
A
Al Viro 已提交
5117 5118
			over = !dir_emit(ctx, name_ptr, name_len,
				       location.objectid, d_type);
5119

5120
skip:
5121 5122 5123
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
5124 5125
			if (over)
				goto nopos;
J
Josef Bacik 已提交
5126
			di_len = btrfs_dir_name_len(leaf, di) +
5127
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
5128 5129 5130
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
5131 5132
next:
		path->slots[0]++;
C
Chris Mason 已提交
5133
	}
5134

5135 5136
	if (key_type == BTRFS_DIR_INDEX_KEY) {
		if (is_curr)
A
Al Viro 已提交
5137 5138
			ctx->pos++;
		ret = btrfs_readdir_delayed_dir_index(ctx, &ins_list);
5139 5140 5141 5142
		if (ret)
			goto nopos;
	}

5143
	/* Reached end of directory/root. Bump pos past the last item. */
5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168
	ctx->pos++;

	/*
	 * Stop new entries from being returned after we return the last
	 * entry.
	 *
	 * New directory entries are assigned a strictly increasing
	 * offset.  This means that new entries created during readdir
	 * are *guaranteed* to be seen in the future by that readdir.
	 * This has broken buggy programs which operate on names as
	 * they're returned by readdir.  Until we re-use freed offsets
	 * we have this hack to stop new entries from being returned
	 * under the assumption that they'll never reach this huge
	 * offset.
	 *
	 * This is being careful not to overflow 32bit loff_t unless the
	 * last entry requires it because doing so has broken 32bit apps
	 * in the past.
	 */
	if (key_type == BTRFS_DIR_INDEX_KEY) {
		if (ctx->pos >= INT_MAX)
			ctx->pos = LLONG_MAX;
		else
			ctx->pos = INT_MAX;
	}
C
Chris Mason 已提交
5169 5170 5171
nopos:
	ret = 0;
err:
5172 5173
	if (key_type == BTRFS_DIR_INDEX_KEY)
		btrfs_put_delayed_items(&ins_list, &del_list);
C
Chris Mason 已提交
5174 5175 5176 5177
	btrfs_free_path(path);
	return ret;
}

5178
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
C
Chris Mason 已提交
5179 5180 5181 5182
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;
5183
	bool nolock = false;
C
Chris Mason 已提交
5184

5185
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5186 5187
		return 0;

5188
	if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
5189
		nolock = true;
5190

5191
	if (wbc->sync_mode == WB_SYNC_ALL) {
5192
		if (nolock)
5193
			trans = btrfs_join_transaction_nolock(root);
5194
		else
5195
			trans = btrfs_join_transaction(root);
5196 5197
		if (IS_ERR(trans))
			return PTR_ERR(trans);
5198
		ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
5199 5200 5201 5202 5203
	}
	return ret;
}

/*
5204
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
5205 5206 5207 5208
 * 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.
 */
5209
static int btrfs_dirty_inode(struct inode *inode)
C
Chris Mason 已提交
5210 5211 5212
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
5213 5214
	int ret;

5215
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5216
		return 0;
C
Chris Mason 已提交
5217

5218
	trans = btrfs_join_transaction(root);
5219 5220
	if (IS_ERR(trans))
		return PTR_ERR(trans);
5221 5222

	ret = btrfs_update_inode(trans, root, inode);
5223 5224 5225 5226
	if (ret && ret == -ENOSPC) {
		/* whoops, lets try again with the full transaction */
		btrfs_end_transaction(trans, root);
		trans = btrfs_start_transaction(root, 1);
5227 5228
		if (IS_ERR(trans))
			return PTR_ERR(trans);
5229

5230 5231
		ret = btrfs_update_inode(trans, root, inode);
	}
C
Chris Mason 已提交
5232
	btrfs_end_transaction(trans, root);
5233 5234
	if (BTRFS_I(inode)->delayed_node)
		btrfs_balance_delayed_items(root);
5235 5236 5237 5238 5239 5240 5241 5242

	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.
 */
5243 5244
static int btrfs_update_time(struct inode *inode, struct timespec *now,
			     int flags)
5245
{
5246 5247 5248 5249 5250
	struct btrfs_root *root = BTRFS_I(inode)->root;

	if (btrfs_root_readonly(root))
		return -EROFS;

5251
	if (flags & S_VERSION)
5252
		inode_inc_iversion(inode);
5253 5254 5255 5256 5257 5258 5259
	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 已提交
5260 5261
}

C
Chris Mason 已提交
5262 5263 5264 5265 5266
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
5267 5268 5269 5270 5271 5272 5273 5274
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 已提交
5275
	key.objectid = btrfs_ino(inode);
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306
	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 已提交
5307
	if (found_key.objectid != btrfs_ino(inode) ||
5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318
	    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 已提交
5319 5320 5321 5322
/*
 * 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
 */
5323
int btrfs_set_inode_index(struct inode *dir, u64 *index)
5324 5325 5326 5327
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
5328 5329 5330 5331 5332 5333
		ret = btrfs_inode_delayed_dir_index_count(dir);
		if (ret) {
			ret = btrfs_set_inode_index_count(dir);
			if (ret)
				return ret;
		}
5334 5335
	}

5336
	*index = BTRFS_I(dir)->index_cnt;
5337 5338 5339 5340 5341
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
5342 5343
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
5344
				     struct inode *dir,
5345
				     const char *name, int name_len,
A
Al Viro 已提交
5346 5347
				     u64 ref_objectid, u64 objectid,
				     umode_t mode, u64 *index)
C
Chris Mason 已提交
5348 5349
{
	struct inode *inode;
5350
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
5351
	struct btrfs_key *location;
5352
	struct btrfs_path *path;
5353 5354 5355 5356
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
5357 5358 5359
	int ret;
	int owner;

5360
	path = btrfs_alloc_path();
5361 5362
	if (!path)
		return ERR_PTR(-ENOMEM);
5363

C
Chris Mason 已提交
5364
	inode = new_inode(root->fs_info->sb);
5365 5366
	if (!inode) {
		btrfs_free_path(path);
C
Chris Mason 已提交
5367
		return ERR_PTR(-ENOMEM);
5368
	}
C
Chris Mason 已提交
5369

5370 5371 5372 5373 5374 5375
	/*
	 * we have to initialize this early, so we can reclaim the inode
	 * number if we fail afterwards in this function.
	 */
	inode->i_ino = objectid;

5376
	if (dir) {
5377 5378
		trace_btrfs_inode_request(dir);

5379
		ret = btrfs_set_inode_index(dir, index);
5380
		if (ret) {
5381
			btrfs_free_path(path);
5382
			iput(inode);
5383
			return ERR_PTR(ret);
5384
		}
5385 5386 5387 5388 5389 5390 5391
	}
	/*
	 * 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 已提交
5392
	BTRFS_I(inode)->root = root;
5393
	BTRFS_I(inode)->generation = trans->transid;
5394
	inode->i_generation = BTRFS_I(inode)->generation;
5395

J
Josef Bacik 已提交
5396 5397 5398 5399 5400 5401 5402 5403
	/*
	 * 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);

5404
	if (S_ISDIR(mode))
C
Chris Mason 已提交
5405 5406 5407
		owner = 0;
	else
		owner = 1;
5408 5409 5410 5411 5412

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

M
Mark Fasheh 已提交
5413 5414 5415 5416 5417 5418
	/*
	 * 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.
	 */
5419 5420 5421 5422 5423 5424 5425
	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);

5426
	path->leave_spinning = 1;
5427 5428
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
5429 5430
		goto fail;

5431
	inode_init_owner(inode, dir, mode);
5432
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
5433
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
5434 5435
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
5436 5437
	memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
			     sizeof(*inode_item));
5438
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
5439 5440 5441 5442

	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);
5443
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
5444 5445 5446
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

5447 5448 5449
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
5450 5451 5452 5453 5454
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

5455 5456
	btrfs_inherit_iflags(inode, dir);

5457
	if (S_ISREG(mode)) {
5458 5459
		if (btrfs_test_opt(root, NODATASUM))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
L
Liu Bo 已提交
5460
		if (btrfs_test_opt(root, NODATACOW))
5461 5462
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |
				BTRFS_INODE_NODATASUM;
5463 5464
	}

5465
	btrfs_insert_inode_hash(inode);
5466
	inode_tree_add(inode);
5467 5468

	trace_btrfs_inode_new(inode);
5469
	btrfs_set_inode_last_trans(trans, inode);
5470

5471 5472
	btrfs_update_root_times(trans, root);

C
Chris Mason 已提交
5473
	return inode;
5474
fail:
5475 5476
	if (dir)
		BTRFS_I(dir)->index_cnt--;
5477
	btrfs_free_path(path);
5478
	iput(inode);
5479
	return ERR_PTR(ret);
C
Chris Mason 已提交
5480 5481 5482 5483 5484 5485 5486
}

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

C
Chris Mason 已提交
5487 5488 5489 5490 5491 5492
/*
 * 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.
 */
5493 5494 5495
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 已提交
5496
{
5497
	int ret = 0;
C
Chris Mason 已提交
5498
	struct btrfs_key key;
5499
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
L
Li Zefan 已提交
5500 5501
	u64 ino = btrfs_ino(inode);
	u64 parent_ino = btrfs_ino(parent_inode);
5502

L
Li Zefan 已提交
5503
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5504 5505
		memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
	} else {
L
Li Zefan 已提交
5506
		key.objectid = ino;
5507 5508 5509 5510
		btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
		key.offset = 0;
	}

L
Li Zefan 已提交
5511
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5512 5513
		ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
					 key.objectid, root->root_key.objectid,
L
Li Zefan 已提交
5514
					 parent_ino, index, name, name_len);
5515
	} else if (add_backref) {
L
Li Zefan 已提交
5516 5517
		ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
					     parent_ino, index);
5518
	}
C
Chris Mason 已提交
5519

5520 5521 5522
	/* Nothing to clean up yet */
	if (ret)
		return ret;
5523

5524 5525 5526
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode, &key,
				    btrfs_inode_type(inode), index);
C
Chris Mason 已提交
5527
	if (ret == -EEXIST || ret == -EOVERFLOW)
5528 5529 5530 5531
		goto fail_dir_item;
	else if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		return ret;
C
Chris Mason 已提交
5532
	}
5533 5534 5535

	btrfs_i_size_write(parent_inode, parent_inode->i_size +
			   name_len * 2);
5536
	inode_inc_iversion(parent_inode);
5537 5538 5539 5540
	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 已提交
5541
	return ret;
5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558

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 已提交
5559 5560 5561
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
5562 5563
			    struct inode *dir, struct dentry *dentry,
			    struct inode *inode, int backref, u64 index)
C
Chris Mason 已提交
5564
{
5565 5566 5567
	int err = btrfs_add_link(trans, dir, inode,
				 dentry->d_name.name, dentry->d_name.len,
				 backref, index);
C
Chris Mason 已提交
5568 5569 5570 5571 5572
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
5573
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
5574
			umode_t mode, dev_t rdev)
J
Josef Bacik 已提交
5575 5576 5577
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
5578
	struct inode *inode = NULL;
J
Josef Bacik 已提交
5579 5580 5581
	int err;
	int drop_inode = 0;
	u64 objectid;
5582
	u64 index = 0;
J
Josef Bacik 已提交
5583 5584 5585 5586

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

J
Josef Bacik 已提交
5587 5588 5589 5590 5591
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
5592 5593 5594
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
5595

5596 5597 5598 5599
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

5600
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5601
				dentry->d_name.len, btrfs_ino(dir), objectid,
5602
				mode, &index);
5603 5604
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
J
Josef Bacik 已提交
5605
		goto out_unlock;
5606
	}
J
Josef Bacik 已提交
5607

5608
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
5609 5610 5611 5612 5613
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

5614 5615 5616 5617 5618 5619 5620 5621
	/*
	* 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;
5622
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
J
Josef Bacik 已提交
5623 5624 5625 5626
	if (err)
		drop_inode = 1;
	else {
		init_special_inode(inode, inode->i_mode, rdev);
5627
		btrfs_update_inode(trans, root, inode);
5628
		d_instantiate(dentry, inode);
J
Josef Bacik 已提交
5629 5630
	}
out_unlock:
5631
	btrfs_end_transaction(trans, root);
5632
	btrfs_btree_balance_dirty(root);
J
Josef Bacik 已提交
5633 5634 5635 5636 5637 5638 5639
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
	return err;
}

C
Chris Mason 已提交
5640
static int btrfs_create(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
5641
			umode_t mode, bool excl)
C
Chris Mason 已提交
5642 5643 5644
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
5645
	struct inode *inode = NULL;
5646
	int drop_inode_on_err = 0;
5647
	int err;
C
Chris Mason 已提交
5648
	u64 objectid;
5649
	u64 index = 0;
C
Chris Mason 已提交
5650

J
Josef Bacik 已提交
5651 5652 5653 5654 5655
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
5656 5657 5658
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
J
Josef Bacik 已提交
5659

5660 5661 5662 5663
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

5664
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5665
				dentry->d_name.len, btrfs_ino(dir), objectid,
5666
				mode, &index);
5667 5668
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
5669
		goto out_unlock;
5670
	}
5671
	drop_inode_on_err = 1;
C
Chris Mason 已提交
5672

5673
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5674
	if (err)
J
Josef Bacik 已提交
5675 5676
		goto out_unlock;

5677 5678 5679 5680
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_unlock;

5681 5682 5683 5684 5685 5686 5687 5688 5689
	/*
	* 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;

5690
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
5691
	if (err)
5692 5693 5694 5695 5696 5697 5698
		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 已提交
5699
out_unlock:
5700
	btrfs_end_transaction(trans, root);
5701
	if (err && drop_inode_on_err) {
C
Chris Mason 已提交
5702 5703 5704
		inode_dec_link_count(inode);
		iput(inode);
	}
5705
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5706 5707 5708 5709 5710 5711 5712 5713 5714
	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;
5715
	u64 index;
C
Chris Mason 已提交
5716 5717 5718
	int err;
	int drop_inode = 0;

5719 5720
	/* do not allow sys_link's with other subvols of the same device */
	if (root->objectid != BTRFS_I(inode)->root->objectid)
5721
		return -EXDEV;
5722

M
Mark Fasheh 已提交
5723
	if (inode->i_nlink >= BTRFS_LINK_MAX)
5724
		return -EMLINK;
5725

5726
	err = btrfs_set_inode_index(dir, &index);
5727 5728 5729
	if (err)
		goto fail;

5730
	/*
M
Miao Xie 已提交
5731
	 * 2 items for inode and inode ref
5732
	 * 2 items for dir items
M
Miao Xie 已提交
5733
	 * 1 item for parent inode
5734
	 */
M
Miao Xie 已提交
5735
	trans = btrfs_start_transaction(root, 5);
5736 5737 5738 5739
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto fail;
	}
5740

5741
	btrfs_inc_nlink(inode);
5742
	inode_inc_iversion(inode);
5743
	inode->i_ctime = CURRENT_TIME;
A
Al Viro 已提交
5744
	ihold(inode);
5745
	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
5746

5747
	err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
5748

5749
	if (err) {
5750
		drop_inode = 1;
5751
	} else {
5752
		struct dentry *parent = dentry->d_parent;
5753
		err = btrfs_update_inode(trans, root, inode);
5754 5755
		if (err)
			goto fail;
5756
		d_instantiate(dentry, inode);
5757
		btrfs_log_new_name(trans, inode, NULL, parent);
5758
	}
C
Chris Mason 已提交
5759

5760
	btrfs_end_transaction(trans, root);
5761
fail:
C
Chris Mason 已提交
5762 5763 5764 5765
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
5766
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5767 5768 5769
	return err;
}

5770
static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
C
Chris Mason 已提交
5771
{
5772
	struct inode *inode = NULL;
C
Chris Mason 已提交
5773 5774 5775 5776
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
5777
	u64 objectid = 0;
5778
	u64 index = 0;
C
Chris Mason 已提交
5779

J
Josef Bacik 已提交
5780 5781 5782 5783 5784
	/*
	 * 2 items for inode and ref
	 * 2 items for dir items
	 * 1 for xattr if selinux is on
	 */
5785 5786 5787
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
5788

5789 5790 5791 5792
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_fail;

5793
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
5794
				dentry->d_name.len, btrfs_ino(dir), objectid,
5795
				S_IFDIR | mode, &index);
C
Chris Mason 已提交
5796 5797 5798 5799
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
5800

C
Chris Mason 已提交
5801
	drop_on_err = 1;
J
Josef Bacik 已提交
5802

5803
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
5804 5805 5806
	if (err)
		goto out_fail;

C
Chris Mason 已提交
5807 5808 5809
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

5810
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
5811 5812 5813
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
5814

5815 5816
	err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
			     dentry->d_name.len, 0, index);
C
Chris Mason 已提交
5817 5818
	if (err)
		goto out_fail;
5819

C
Chris Mason 已提交
5820 5821 5822 5823
	d_instantiate(dentry, inode);
	drop_on_err = 0;

out_fail:
5824
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
5825 5826
	if (drop_on_err)
		iput(inode);
5827
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5828 5829 5830
	return err;
}

C
Chris Mason 已提交
5831 5832 5833 5834
/* 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.
 */
5835 5836
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
5837 5838
				struct extent_map *em,
				u64 map_start, u64 map_len)
5839 5840 5841
{
	u64 start_diff;

5842 5843 5844 5845
	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 已提交
5846 5847
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
5848
		em->block_start += start_diff;
C
Chris Mason 已提交
5849 5850
		em->block_len -= start_diff;
	}
J
Josef Bacik 已提交
5851
	return add_extent_mapping(em_tree, em, 0);
5852 5853
}

C
Chris Mason 已提交
5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864
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;
5865
	int compress_type;
C
Chris Mason 已提交
5866 5867

	WARN_ON(pg_offset != 0);
5868
	compress_type = btrfs_file_extent_compression(leaf, item);
C
Chris Mason 已提交
5869 5870
	max_size = btrfs_file_extent_ram_bytes(leaf, item);
	inline_size = btrfs_file_extent_inline_item_len(leaf,
5871
					btrfs_item_nr(path->slots[0]));
C
Chris Mason 已提交
5872
	tmp = kmalloc(inline_size, GFP_NOFS);
5873 5874
	if (!tmp)
		return -ENOMEM;
C
Chris Mason 已提交
5875 5876 5877 5878
	ptr = btrfs_file_extent_inline_start(item);

	read_extent_buffer(leaf, tmp, ptr, inline_size);

5879
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
5880 5881
	ret = btrfs_decompress(compress_type, tmp, page,
			       extent_offset, inline_size, max_size);
C
Chris Mason 已提交
5882
	if (ret) {
5883
		char *kaddr = kmap_atomic(page);
C
Chris Mason 已提交
5884 5885 5886 5887
		unsigned long copy_size = min_t(u64,
				  PAGE_CACHE_SIZE - pg_offset,
				  max_size - extent_offset);
		memset(kaddr + pg_offset, 0, copy_size);
5888
		kunmap_atomic(kaddr);
C
Chris Mason 已提交
5889 5890 5891 5892 5893
	}
	kfree(tmp);
	return 0;
}

C
Chris Mason 已提交
5894 5895
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
C
Chris Mason 已提交
5896 5897
 * 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 已提交
5898 5899 5900 5901
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
C
Chris Mason 已提交
5902

5903
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
5904
				    size_t pg_offset, u64 start, u64 len,
5905 5906 5907 5908
				    int create)
{
	int ret;
	int err = 0;
5909
	u64 bytenr;
5910 5911
	u64 extent_start = 0;
	u64 extent_end = 0;
L
Li Zefan 已提交
5912
	u64 objectid = btrfs_ino(inode);
5913
	u32 found_type;
5914
	struct btrfs_path *path = NULL;
5915 5916
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
5917 5918
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
5919 5920
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5921
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
5922
	struct btrfs_trans_handle *trans = NULL;
5923
	int compress_type;
5924 5925

again:
5926
	read_lock(&em_tree->lock);
5927
	em = lookup_extent_mapping(em_tree, start, len);
5928 5929
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
5930
	read_unlock(&em_tree->lock);
5931

5932
	if (em) {
5933 5934 5935
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
5936 5937 5938
			free_extent_map(em);
		else
			goto out;
5939
	}
5940
	em = alloc_extent_map();
5941
	if (!em) {
5942 5943
		err = -ENOMEM;
		goto out;
5944
	}
5945
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5946
	em->start = EXTENT_MAP_HOLE;
5947
	em->orig_start = EXTENT_MAP_HOLE;
5948
	em->len = (u64)-1;
C
Chris Mason 已提交
5949
	em->block_len = (u64)-1;
5950 5951 5952

	if (!path) {
		path = btrfs_alloc_path();
J
Josef Bacik 已提交
5953 5954 5955 5956 5957 5958 5959 5960 5961
		if (!path) {
			err = -ENOMEM;
			goto out;
		}
		/*
		 * Chances are we'll be called again, so go ahead and do
		 * readahead
		 */
		path->reada = 1;
5962 5963
	}

5964 5965
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

5977 5978
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
5979 5980
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
5981 5982 5983
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
5984 5985 5986 5987
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

5988 5989
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
5990
	compress_type = btrfs_file_extent_compression(leaf, item);
Y
Yan Zheng 已提交
5991 5992
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5993
		extent_end = extent_start +
5994
		       btrfs_file_extent_num_bytes(leaf, item);
Y
Yan Zheng 已提交
5995 5996 5997
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
		size_t size;
		size = btrfs_file_extent_inline_len(leaf, item);
5998
		extent_end = ALIGN(extent_start + size, root->sectorsize);
Y
Yan Zheng 已提交
5999 6000 6001 6002 6003 6004 6005 6006 6007
	}

	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;
6008
			}
Y
Yan Zheng 已提交
6009 6010 6011
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
6012
		}
Y
Yan Zheng 已提交
6013 6014 6015 6016 6017 6018 6019
		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;
6020
		em->orig_start = start;
Y
Yan Zheng 已提交
6021 6022 6023 6024
		em->len = found_key.offset - start;
		goto not_found_em;
	}

J
Josef Bacik 已提交
6025
	em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, item);
Y
Yan Zheng 已提交
6026 6027
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
6028 6029
		em->start = extent_start;
		em->len = extent_end - extent_start;
6030 6031
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
6032 6033
		em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
								      item);
6034 6035
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
6036
			em->block_start = EXTENT_MAP_HOLE;
6037 6038
			goto insert;
		}
6039
		if (compress_type != BTRFS_COMPRESS_NONE) {
C
Chris Mason 已提交
6040
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6041
			em->compress_type = compress_type;
C
Chris Mason 已提交
6042
			em->block_start = bytenr;
6043
			em->block_len = em->orig_block_len;
C
Chris Mason 已提交
6044 6045 6046 6047
		} else {
			bytenr += btrfs_file_extent_offset(leaf, item);
			em->block_start = bytenr;
			em->block_len = em->len;
Y
Yan Zheng 已提交
6048 6049
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
C
Chris Mason 已提交
6050
		}
6051 6052
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6053
		unsigned long ptr;
6054
		char *map;
6055 6056 6057
		size_t size;
		size_t extent_offset;
		size_t copy_size;
6058

6059
		em->block_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
6060
		if (!page || create) {
6061
			em->start = extent_start;
Y
Yan Zheng 已提交
6062
			em->len = extent_end - extent_start;
6063 6064
			goto out;
		}
6065

Y
Yan Zheng 已提交
6066 6067
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
6068
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
6069 6070
				size - extent_offset);
		em->start = extent_start + extent_offset;
6071
		em->len = ALIGN(copy_size, root->sectorsize);
6072
		em->orig_block_len = em->len;
6073
		em->orig_start = em->start;
6074
		if (compress_type) {
C
Chris Mason 已提交
6075
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6076 6077
			em->compress_type = compress_type;
		}
6078
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
6079
		if (create == 0 && !PageUptodate(page)) {
6080 6081
			if (btrfs_file_extent_compression(leaf, item) !=
			    BTRFS_COMPRESS_NONE) {
C
Chris Mason 已提交
6082 6083 6084
				ret = uncompress_inline(path, inode, page,
							pg_offset,
							extent_offset, item);
6085
				BUG_ON(ret); /* -ENOMEM */
C
Chris Mason 已提交
6086 6087 6088 6089
			} else {
				map = kmap(page);
				read_extent_buffer(leaf, map + pg_offset, ptr,
						   copy_size);
6090 6091 6092 6093 6094
				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 已提交
6095 6096
				kunmap(page);
			}
6097 6098
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
6099
			BUG();
6100 6101 6102 6103
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
C
Chris Mason 已提交
6104

6105
				btrfs_release_path(path);
6106
				trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
6107

6108 6109
				if (IS_ERR(trans))
					return ERR_CAST(trans);
6110 6111
				goto again;
			}
C
Chris Mason 已提交
6112
			map = kmap(page);
6113
			write_extent_buffer(leaf, map + pg_offset, ptr,
6114
					    copy_size);
C
Chris Mason 已提交
6115
			kunmap(page);
6116
			btrfs_mark_buffer_dirty(leaf);
6117
		}
6118
		set_extent_uptodate(io_tree, em->start,
6119
				    extent_map_end(em) - 1, NULL, GFP_NOFS);
6120 6121
		goto insert;
	} else {
J
Julia Lawall 已提交
6122
		WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
6123 6124 6125
	}
not_found:
	em->start = start;
6126
	em->orig_start = start;
6127
	em->len = len;
6128
not_found_em:
6129
	em->block_start = EXTENT_MAP_HOLE;
Y
Yan Zheng 已提交
6130
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
6131
insert:
6132
	btrfs_release_path(path);
6133
	if (em->start > start || extent_map_end(em) <= start) {
6134
		btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]",
6135
			em->start, em->len, start, len);
6136 6137 6138
		err = -EIO;
		goto out;
	}
6139 6140

	err = 0;
6141
	write_lock(&em_tree->lock);
J
Josef Bacik 已提交
6142
	ret = add_extent_mapping(em_tree, em, 0);
6143 6144 6145 6146
	/* 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
	 */
6147
	if (ret == -EEXIST) {
6148
		struct extent_map *existing;
6149 6150 6151

		ret = 0;

6152
		existing = lookup_extent_mapping(em_tree, start, len);
6153 6154 6155 6156 6157
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
6158 6159 6160 6161 6162
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
6163 6164
							   em, start,
							   root->sectorsize);
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177
				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;
6178
			err = 0;
6179 6180
		}
	}
6181
	write_unlock(&em_tree->lock);
6182
out:
6183

6184 6185
	if (em)
		trace_btrfs_get_extent(root, em);
6186

6187 6188
	if (path)
		btrfs_free_path(path);
6189 6190
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
6191
		if (!err)
6192 6193 6194 6195 6196 6197
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
6198
	BUG_ON(!em); /* Error is always set */
6199 6200 6201
	return em;
}

6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
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) {
		/*
6219 6220 6221 6222
		 * if our em maps to
		 * -  a hole or
		 * -  a pre-alloc extent,
		 * there might actually be delalloc bytes behind it.
6223
		 */
6224 6225
		if (em->block_start != EXTENT_MAP_HOLE &&
		    !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266
			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;

6267
		em = alloc_extent_map();
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 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306
		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;
6307 6308
			if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328
		} 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;
}

6329 6330 6331 6332
static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
						  u64 start, u64 len)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
6333
	struct extent_map *em;
6334 6335 6336 6337 6338
	struct btrfs_key ins;
	u64 alloc_hint;
	int ret;

	alloc_hint = get_extent_allocation_hint(inode, start, len);
6339
	ret = btrfs_reserve_extent(root, len, root->sectorsize, 0,
6340
				   alloc_hint, &ins, 1);
6341 6342
	if (ret)
		return ERR_PTR(ret);
6343

6344
	em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
J
Josef Bacik 已提交
6345
			      ins.offset, ins.offset, ins.offset, 0);
6346 6347 6348 6349
	if (IS_ERR(em)) {
		btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
		return em;
	}
6350 6351 6352 6353 6354

	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);
6355 6356
		free_extent_map(em);
		return ERR_PTR(ret);
6357
	}
6358

6359 6360 6361
	return em;
}

6362 6363 6364 6365
/*
 * returns 1 when the nocow is safe, < 1 on error, 0 if the
 * block must be cow'd
 */
6366
noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
6367 6368
			      u64 *orig_start, u64 *orig_block_len,
			      u64 *ram_bytes)
6369
{
6370
	struct btrfs_trans_handle *trans;
6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382
	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;
6383
	bool nocow = (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW);
6384 6385 6386 6387
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

6388
	ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(inode),
6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404
				       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 已提交
6405
	if (key.objectid != btrfs_ino(inode) ||
6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422
	    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;
	}
6423 6424 6425 6426

	if (!nocow && found_type == BTRFS_FILE_EXTENT_REG)
		goto out;

6427
	disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
6428 6429 6430 6431 6432 6433 6434 6435
	if (disk_bytenr == 0)
		goto out;

	if (btrfs_file_extent_compression(leaf, fi) ||
	    btrfs_file_extent_encryption(leaf, fi) ||
	    btrfs_file_extent_other_encoding(leaf, fi))
		goto out;

6436 6437
	backref_offset = btrfs_file_extent_offset(leaf, fi);

6438 6439 6440 6441 6442
	if (orig_start) {
		*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);
	}
6443

6444 6445 6446 6447
	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);

	if (btrfs_extent_readonly(root, disk_bytenr))
		goto out;
6448
	btrfs_release_path(path);
6449 6450 6451 6452 6453

	/*
	 * look for other files referencing this extent, if we
	 * find any we must cow
	 */
6454 6455 6456
	trans = btrfs_join_transaction(root);
	if (IS_ERR(trans)) {
		ret = 0;
6457
		goto out;
6458 6459 6460 6461 6462 6463 6464 6465 6466
	}

	ret = btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
				    key.offset - backref_offset, disk_bytenr);
	btrfs_end_transaction(trans, root);
	if (ret) {
		ret = 0;
		goto out;
	}
6467 6468 6469 6470 6471 6472 6473 6474 6475

	/*
	 * 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;
6476
	num_bytes = min(offset + *len, extent_end) - offset;
6477 6478 6479 6480 6481 6482
	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
	 */
6483
	*len = num_bytes;
6484 6485 6486 6487 6488 6489
	ret = 1;
out:
	btrfs_free_path(path);
	return ret;
}

6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 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
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;
}

6551 6552 6553
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 已提交
6554 6555
					   u64 orig_block_len, u64 ram_bytes,
					   int type)
6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568
{
	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;
6569 6570
	em->mod_start = start;
	em->mod_len = len;
6571 6572 6573 6574
	em->len = len;
	em->block_len = block_len;
	em->block_start = block_start;
	em->bdev = root->fs_info->fs_devices->latest_bdev;
6575
	em->orig_block_len = orig_block_len;
J
Josef Bacik 已提交
6576
	em->ram_bytes = ram_bytes;
6577
	em->generation = -1;
6578 6579
	set_bit(EXTENT_FLAG_PINNED, &em->flags);
	if (type == BTRFS_ORDERED_PREALLOC)
6580
		set_bit(EXTENT_FLAG_FILLING, &em->flags);
6581 6582 6583 6584 6585

	do {
		btrfs_drop_extent_cache(inode, em->start,
				em->start + em->len - 1, 0);
		write_lock(&em_tree->lock);
J
Josef Bacik 已提交
6586
		ret = add_extent_mapping(em_tree, em, 1);
6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598
		write_unlock(&em_tree->lock);
	} while (ret == -EEXIST);

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

	return em;
}


6599 6600 6601 6602 6603
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;
6604
	struct extent_state *cached_state = NULL;
6605
	u64 start = iblock << inode->i_blkbits;
6606
	u64 lockstart, lockend;
6607
	u64 len = bh_result->b_size;
6608
	int unlock_bits = EXTENT_LOCKED;
6609
	int ret = 0;
6610

6611
	if (create)
6612
		unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY;
6613
	else
6614
		len = min_t(u64, len, root->sectorsize);
6615

6616 6617 6618
	lockstart = start;
	lockend = start + len - 1;

6619 6620 6621 6622 6623 6624 6625
	/*
	 * 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;

6626
	em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
6627 6628 6629 6630
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648

	/*
	 * 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);
6649 6650
		ret = -ENOTBLK;
		goto unlock_err;
6651 6652 6653 6654 6655 6656
	}

	/* 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);
6657
		goto unlock_err;
6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668
	}

	/*
	 * 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.
	 *
	 */
6669
	if (!create) {
6670 6671 6672
		len = min(len, em->len - (start - em->start));
		lockstart = start + len;
		goto unlock;
6673
	}
6674 6675 6676 6677 6678 6679

	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;
6680
		u64 block_start, orig_start, orig_block_len, ram_bytes;
6681 6682 6683 6684 6685

		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
			type = BTRFS_ORDERED_PREALLOC;
		else
			type = BTRFS_ORDERED_NOCOW;
6686
		len = min(len, em->len - (start - em->start));
6687
		block_start = em->block_start + (start - em->start);
6688

6689
		if (can_nocow_extent(inode, start, &len, &orig_start,
6690
				     &orig_block_len, &ram_bytes) == 1) {
6691 6692 6693 6694
			if (type == BTRFS_ORDERED_PREALLOC) {
				free_extent_map(em);
				em = create_pinned_em(inode, start, len,
						       orig_start,
6695
						       block_start, len,
J
Josef Bacik 已提交
6696 6697
						       orig_block_len,
						       ram_bytes, type);
6698
				if (IS_ERR(em))
6699 6700 6701
					goto unlock_err;
			}

6702 6703 6704 6705
			ret = btrfs_add_ordered_extent_dio(inode, start,
					   block_start, len, len, type);
			if (ret) {
				free_extent_map(em);
6706
				goto unlock_err;
6707 6708
			}
			goto unlock;
6709 6710
		}
	}
6711

6712 6713 6714 6715 6716
	/*
	 * this will cow the extent, reset the len in case we changed
	 * it above
	 */
	len = bh_result->b_size;
6717 6718
	free_extent_map(em);
	em = btrfs_new_extent_direct(inode, start, len);
6719 6720 6721 6722
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
6723 6724
	len = min(len, em->len - (start - em->start));
unlock:
6725 6726
	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
		inode->i_blkbits;
6727
	bh_result->b_size = len;
6728 6729
	bh_result->b_bdev = em->bdev;
	set_buffer_mapped(bh_result);
6730 6731 6732 6733 6734 6735 6736 6737 6738 6739
	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);
6740

6741 6742 6743 6744
		spin_lock(&BTRFS_I(inode)->lock);
		BTRFS_I(inode)->outstanding_extents++;
		spin_unlock(&BTRFS_I(inode)->lock);

6745 6746 6747 6748
		ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
				     lockstart + len - 1, EXTENT_DELALLOC, NULL,
				     &cached_state, GFP_NOFS);
		BUG_ON(ret);
6749
	}
6750

6751 6752 6753 6754 6755
	/*
	 * 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 已提交
6756
	if (lockstart < lockend) {
6757 6758 6759
		clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
				 lockend, unlock_bits, 1, 0,
				 &cached_state, GFP_NOFS);
L
Liu Bo 已提交
6760
	} else {
6761
		free_extent_state(cached_state);
L
Liu Bo 已提交
6762
	}
6763

6764 6765 6766
	free_extent_map(em);

	return 0;
6767 6768 6769 6770 6771

unlock_err:
	clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
			 unlock_bits, 1, 0, &cached_state, GFP_NOFS);
	return ret;
6772 6773 6774 6775
}

static void btrfs_endio_direct_read(struct bio *bio, int err)
{
M
Miao Xie 已提交
6776
	struct btrfs_dio_private *dip = bio->bi_private;
6777 6778 6779 6780
	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;
	struct btrfs_root *root = BTRFS_I(inode)->root;
6781
	struct bio *dio_bio;
6782 6783
	u32 *csums = (u32 *)dip->csum;
	int index = 0;
6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794
	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;
			unsigned long flags;

			local_irq_save(flags);
6795
			kaddr = kmap_atomic(page);
6796
			csum = btrfs_csum_data(kaddr + bvec->bv_offset,
6797 6798
					       csum, bvec->bv_len);
			btrfs_csum_final(csum, (char *)&csum);
6799
			kunmap_atomic(kaddr);
6800 6801 6802
			local_irq_restore(flags);

			flush_dcache_page(bvec->bv_page);
6803 6804
			if (csum != csums[index]) {
				btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u expected csum %u",
6805 6806
					  btrfs_ino(inode), start, csum,
					  csums[index]);
6807 6808 6809 6810 6811 6812
				err = -EIO;
			}
		}

		start += bvec->bv_len;
		bvec++;
6813
		index++;
6814 6815 6816
	} while (bvec <= bvec_end);

	unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
6817
		      dip->logical_offset + dip->bytes - 1);
6818
	dio_bio = dip->dio_bio;
6819 6820

	kfree(dip);
6821 6822 6823

	/* If we had a csum failure make sure to clear the uptodate flag */
	if (err)
6824 6825 6826
		clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
	dio_end_io(dio_bio, err);
	bio_put(bio);
6827 6828 6829 6830 6831 6832 6833 6834
}

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;
6835 6836
	u64 ordered_offset = dip->logical_offset;
	u64 ordered_bytes = dip->bytes;
6837
	struct bio *dio_bio;
6838 6839 6840 6841
	int ret;

	if (err)
		goto out_done;
6842 6843 6844
again:
	ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
						   &ordered_offset,
6845
						   ordered_bytes, !err);
6846
	if (!ret)
6847
		goto out_test;
6848

6849 6850 6851 6852
	ordered->work.func = finish_ordered_fn;
	ordered->work.flags = 0;
	btrfs_queue_worker(&root->fs_info->endio_write_workers,
			   &ordered->work);
6853 6854 6855 6856 6857 6858 6859 6860
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;
6861
		ordered = NULL;
6862 6863
		goto again;
	}
6864
out_done:
6865
	dio_bio = dip->dio_bio;
6866 6867

	kfree(dip);
6868 6869 6870

	/* If we had an error make sure to clear the uptodate flag */
	if (err)
6871 6872 6873
		clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
	dio_end_io(dio_bio, err);
	bio_put(bio);
6874 6875
}

6876 6877 6878 6879 6880 6881 6882
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);
6883
	BUG_ON(ret); /* -ENOMEM */
6884 6885 6886
	return 0;
}

M
Miao Xie 已提交
6887 6888 6889 6890 6891
static void btrfs_end_dio_bio(struct bio *bio, int err)
{
	struct btrfs_dio_private *dip = bio->bi_private;

	if (err) {
L
Li Zefan 已提交
6892
		printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
J
Jan Beulich 已提交
6893
		      "sector %#Lx len %u err no %d\n",
6894
		      btrfs_ino(dip->inode), bio->bi_rw,
J
Jan Beulich 已提交
6895
		      (unsigned long long)bio->bi_sector, bio->bi_size, err);
M
Miao Xie 已提交
6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908
		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;

6909
	if (dip->errors) {
M
Miao Xie 已提交
6910
		bio_io_error(dip->orig_bio);
6911 6912
	} else {
		set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags);
M
Miao Xie 已提交
6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927
		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,
6928
					 int async_submit)
M
Miao Xie 已提交
6929
{
6930
	struct btrfs_dio_private *dip = bio->bi_private;
M
Miao Xie 已提交
6931 6932 6933 6934
	int write = rw & REQ_WRITE;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

6935 6936 6937
	if (async_submit)
		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);

M
Miao Xie 已提交
6938
	bio_get(bio);
6939 6940 6941 6942 6943 6944

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

6946 6947 6948 6949
	if (skip_sum)
		goto map;

	if (write && async_submit) {
M
Miao Xie 已提交
6950 6951 6952 6953 6954 6955
		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;
6956 6957 6958 6959 6960 6961 6962 6963
	} 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;
6964
	} else if (!skip_sum) {
6965 6966
		ret = btrfs_lookup_bio_sums_dio(root, inode, dip, bio,
						file_offset);
6967 6968 6969
		if (ret)
			goto err;
	}
M
Miao Xie 已提交
6970

6971 6972
map:
	ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
M
Miao Xie 已提交
6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991
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;
6992
	int async_submit = 0;
M
Miao Xie 已提交
6993 6994

	map_length = orig_bio->bi_size;
D
David Woodhouse 已提交
6995
	ret = btrfs_map_block(root->fs_info, rw, start_sector << 9,
M
Miao Xie 已提交
6996 6997
			      &map_length, NULL, 0);
	if (ret) {
6998
		bio_put(orig_bio);
M
Miao Xie 已提交
6999 7000
		return -EIO;
	}
7001

7002 7003 7004 7005 7006
	if (map_length >= orig_bio->bi_size) {
		bio = orig_bio;
		goto submit;
	}

D
David Woodhouse 已提交
7007 7008 7009 7010 7011 7012 7013
	/* 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;

7014 7015 7016 7017 7018 7019 7020
	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 已提交
7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033
	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,
7034
						     async_submit);
M
Miao Xie 已提交
7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054
			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 已提交
7055
			ret = btrfs_map_block(root->fs_info, rw,
7056
					      start_sector << 9,
M
Miao Xie 已提交
7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068
					      &map_length, NULL, 0);
			if (ret) {
				bio_put(bio);
				goto out_err;
			}
		} else {
			submit_len += bvec->bv_len;
			nr_pages ++;
			bvec++;
		}
	}

7069
submit:
M
Miao Xie 已提交
7070
	ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
7071
				     async_submit);
M
Miao Xie 已提交
7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089
	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;
}

7090 7091
static void btrfs_submit_direct(int rw, struct bio *dio_bio,
				struct inode *inode, loff_t file_offset)
7092 7093 7094
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_dio_private *dip;
7095
	struct bio *io_bio;
7096
	int skip_sum;
7097
	int sum_len;
7098
	int write = rw & REQ_WRITE;
7099
	int ret = 0;
7100
	u16 csum_size;
7101 7102 7103

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

7104 7105 7106 7107 7108 7109
	io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);
	if (!io_bio) {
		ret = -ENOMEM;
		goto free_ordered;
	}

7110 7111 7112 7113 7114 7115 7116 7117 7118
	if (!skip_sum && !write) {
		csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
		sum_len = dio_bio->bi_size >> inode->i_sb->s_blocksize_bits;
		sum_len *= csum_size;
	} else {
		sum_len = 0;
	}

	dip = kmalloc(sizeof(*dip) + sum_len, GFP_NOFS);
7119 7120
	if (!dip) {
		ret = -ENOMEM;
7121
		goto free_io_bio;
7122 7123
	}

7124
	dip->private = dio_bio->bi_private;
7125 7126
	dip->inode = inode;
	dip->logical_offset = file_offset;
7127
	dip->bytes = dio_bio->bi_size;
7128 7129
	dip->disk_bytenr = (u64)dio_bio->bi_sector << 9;
	io_bio->bi_private = dip;
M
Miao Xie 已提交
7130
	dip->errors = 0;
7131 7132
	dip->orig_bio = io_bio;
	dip->dio_bio = dio_bio;
M
Miao Xie 已提交
7133
	atomic_set(&dip->pending_bios, 0);
7134 7135

	if (write)
7136
		io_bio->bi_end_io = btrfs_endio_direct_write;
7137
	else
7138
		io_bio->bi_end_io = btrfs_endio_direct_read;
7139

M
Miao Xie 已提交
7140 7141
	ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
	if (!ret)
7142
		return;
7143 7144 7145 7146

free_io_bio:
	bio_put(io_bio);

7147 7148 7149 7150 7151 7152 7153
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;
7154
		ordered = btrfs_lookup_ordered_extent(inode, file_offset);
7155 7156 7157 7158 7159 7160 7161
		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);
	}
7162
	bio_endio(dio_bio, ret);
7163 7164
}

C
Chris Mason 已提交
7165 7166 7167 7168 7169
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;
7170
	int i;
C
Chris Mason 已提交
7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184
	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;
7185
		if ((addr & blocksize_mask) || (size & blocksize_mask))
C
Chris Mason 已提交
7186
			goto out;
7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200

		/* 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 已提交
7201 7202 7203 7204 7205
	}
	retval = 0;
out:
	return retval;
}
7206

7207 7208 7209 7210
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
7211 7212
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
7213
	size_t count = 0;
7214
	int flags = 0;
M
Miao Xie 已提交
7215 7216
	bool wakeup = true;
	bool relock = false;
7217
	ssize_t ret;
7218

C
Chris Mason 已提交
7219
	if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
7220
			    offset, nr_segs))
C
Chris Mason 已提交
7221
		return 0;
7222

M
Miao Xie 已提交
7223 7224 7225
	atomic_inc(&inode->i_dio_count);
	smp_mb__after_atomic_inc();

7226 7227 7228 7229 7230 7231 7232 7233 7234
	/*
	 * The generic stuff only does filemap_write_and_wait_range, which isn't
	 * enough if we've written compressed pages to this area, so we need to
	 * call btrfs_wait_ordered_range to make absolutely sure that any
	 * outstanding dirty pages are on disk.
	 */
	count = iov_length(iov, nr_segs);
	btrfs_wait_ordered_range(inode, offset, count);

7235
	if (rw & WRITE) {
M
Miao Xie 已提交
7236 7237 7238 7239 7240 7241 7242 7243 7244
		/*
		 * 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;
		}
7245 7246
		ret = btrfs_delalloc_reserve_space(inode, count);
		if (ret)
M
Miao Xie 已提交
7247 7248 7249 7250 7251 7252
			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;
7253 7254 7255 7256 7257
	}

	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,
7258
			btrfs_submit_direct, flags);
7259 7260 7261
	if (rw & WRITE) {
		if (ret < 0 && ret != -EIOCBQUEUED)
			btrfs_delalloc_release_space(inode, count);
7262
		else if (ret >= 0 && (size_t)ret < count)
7263 7264
			btrfs_delalloc_release_space(inode,
						     count - (size_t)ret);
7265 7266
		else
			btrfs_delalloc_release_metadata(inode, 0);
7267
	}
M
Miao Xie 已提交
7268
out:
7269 7270
	if (wakeup)
		inode_dio_done(inode);
M
Miao Xie 已提交
7271 7272
	if (relock)
		mutex_lock(&inode->i_mutex);
7273 7274

	return ret;
7275 7276
}

T
Tsutomu Itoh 已提交
7277 7278
#define BTRFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC)

Y
Yehuda Sadeh 已提交
7279 7280 7281
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
T
Tsutomu Itoh 已提交
7282 7283 7284 7285 7286 7287
	int	ret;

	ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
	if (ret)
		return ret;

7288
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
Y
Yehuda Sadeh 已提交
7289 7290
}

7291
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
7292
{
7293 7294
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
7295
	return extent_read_full_page(tree, page, btrfs_get_extent, 0);
C
Chris Mason 已提交
7296
}
7297

7298
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
7299
{
7300
	struct extent_io_tree *tree;
7301 7302 7303 7304 7305 7306 7307


	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
7308
	tree = &BTRFS_I(page->mapping->host)->io_tree;
7309
	return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
C
Chris Mason 已提交
7310 7311
}

7312 7313
static int btrfs_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
C
Chris Mason 已提交
7314
{
7315
	struct extent_io_tree *tree;
7316

7317
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
7318 7319 7320
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
7321 7322 7323 7324
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
7325 7326
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
7327 7328 7329
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
7330
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
C
Chris Mason 已提交
7331
{
7332 7333
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
7334
	int ret;
7335

7336 7337
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
7338
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
7339 7340 7341 7342
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
7343
	}
7344
	return ret;
C
Chris Mason 已提交
7345 7346
}

7347 7348
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
7349 7350
	if (PageWriteback(page) || PageDirty(page))
		return 0;
7351
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
7352 7353
}

7354 7355
static void btrfs_invalidatepage(struct page *page, unsigned int offset,
				 unsigned int length)
C
Chris Mason 已提交
7356
{
7357
	struct inode *inode = page->mapping->host;
7358
	struct extent_io_tree *tree;
7359
	struct btrfs_ordered_extent *ordered;
7360
	struct extent_state *cached_state = NULL;
7361 7362
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
7363

7364 7365 7366 7367 7368 7369 7370
	/*
	 * 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
	 */
7371
	wait_on_page_writeback(page);
7372

7373
	tree = &BTRFS_I(inode)->io_tree;
7374 7375 7376 7377
	if (offset) {
		btrfs_releasepage(page, GFP_NOFS);
		return;
	}
7378
	lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
M
Miao Xie 已提交
7379
	ordered = btrfs_lookup_ordered_extent(inode, page_offset(page));
7380
	if (ordered) {
7381 7382 7383 7384
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
7385 7386
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
7387 7388
				 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
				 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
7389 7390 7391 7392
		/*
		 * whoever cleared the private bit is responsible
		 * for the finish_ordered_io
		 */
7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409
		if (TestClearPagePrivate2(page)) {
			struct btrfs_ordered_inode_tree *tree;
			u64 new_len;

			tree = &BTRFS_I(inode)->ordered_tree;

			spin_lock_irq(&tree->lock);
			set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
			new_len = page_start - ordered->file_offset;
			if (new_len < ordered->truncated_len)
				ordered->truncated_len = new_len;
			spin_unlock_irq(&tree->lock);

			if (btrfs_dec_test_ordered_pending(inode, &ordered,
							   page_start,
							   PAGE_CACHE_SIZE, 1))
				btrfs_finish_ordered_io(ordered);
7410
		}
7411
		btrfs_put_ordered_extent(ordered);
7412
		cached_state = NULL;
7413
		lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
7414 7415
	}
	clear_extent_bit(tree, page_start, page_end,
7416
		 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
7417 7418
		 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
		 &cached_state, GFP_NOFS);
7419 7420
	__btrfs_releasepage(page, GFP_NOFS);

C
Chris Mason 已提交
7421
	ClearPageChecked(page);
7422 7423 7424 7425 7426
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
7427 7428
}

C
Chris Mason 已提交
7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443
/*
 * 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.
 */
7444
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
C
Chris Mason 已提交
7445
{
7446
	struct page *page = vmf->page;
A
Al Viro 已提交
7447
	struct inode *inode = file_inode(vma->vm_file);
7448
	struct btrfs_root *root = BTRFS_I(inode)->root;
7449 7450
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
7451
	struct extent_state *cached_state = NULL;
7452 7453
	char *kaddr;
	unsigned long zero_start;
C
Chris Mason 已提交
7454
	loff_t size;
7455
	int ret;
7456
	int reserved = 0;
7457
	u64 page_start;
7458
	u64 page_end;
C
Chris Mason 已提交
7459

7460
	sb_start_pagefault(inode->i_sb);
7461
	ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
7462
	if (!ret) {
7463
		ret = file_update_time(vma->vm_file);
7464 7465
		reserved = 1;
	}
7466 7467 7468 7469 7470
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
7471 7472 7473
		if (reserved)
			goto out;
		goto out_noreserve;
7474
	}
7475

7476
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
7477
again:
C
Chris Mason 已提交
7478 7479
	lock_page(page);
	size = i_size_read(inode);
7480 7481
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
7482

C
Chris Mason 已提交
7483
	if ((page->mapping != inode->i_mapping) ||
7484
	    (page_start >= size)) {
C
Chris Mason 已提交
7485 7486 7487
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
7488 7489
	wait_on_page_writeback(page);

7490
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
7491 7492
	set_page_extent_mapped(page);

7493 7494 7495 7496
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
7497 7498
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
7499 7500
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
7501
		unlock_page(page);
7502
		btrfs_start_ordered_extent(inode, ordered, 1);
7503 7504 7505 7506
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

J
Josef Bacik 已提交
7507 7508 7509 7510 7511 7512 7513
	/*
	 * 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.
	 */
7514
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
7515 7516
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
7517
			  0, 0, &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
7518

7519 7520
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
J
Josef Bacik 已提交
7521
	if (ret) {
7522 7523
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
7524 7525 7526
		ret = VM_FAULT_SIGBUS;
		goto out_unlock;
	}
7527
	ret = 0;
C
Chris Mason 已提交
7528 7529

	/* page is wholly or partially inside EOF */
7530
	if (page_start + PAGE_CACHE_SIZE > size)
7531
		zero_start = size & ~PAGE_CACHE_MASK;
C
Chris Mason 已提交
7532
	else
7533
		zero_start = PAGE_CACHE_SIZE;
C
Chris Mason 已提交
7534

7535 7536 7537 7538 7539 7540
	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);
	}
7541
	ClearPageChecked(page);
7542
	set_page_dirty(page);
7543
	SetPageUptodate(page);
7544

7545 7546
	BTRFS_I(inode)->last_trans = root->fs_info->generation;
	BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
7547
	BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
7548

7549
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
7550 7551

out_unlock:
7552 7553
	if (!ret) {
		sb_end_pagefault(inode->i_sb);
7554
		return VM_FAULT_LOCKED;
7555
	}
C
Chris Mason 已提交
7556
	unlock_page(page);
7557
out:
7558
	btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
7559
out_noreserve:
7560
	sb_end_pagefault(inode->i_sb);
C
Chris Mason 已提交
7561 7562 7563
	return ret;
}

7564
static int btrfs_truncate(struct inode *inode)
C
Chris Mason 已提交
7565 7566
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
7567
	struct btrfs_block_rsv *rsv;
7568
	int ret = 0;
7569
	int err = 0;
C
Chris Mason 已提交
7570
	struct btrfs_trans_handle *trans;
7571
	u64 mask = root->sectorsize - 1;
7572
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
7573

C
Chris Mason 已提交
7574
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
C
Chris Mason 已提交
7575

7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611
	/*
	 * 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.
	 */
7612
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
7613 7614
	if (!rsv)
		return -ENOMEM;
J
Josef Bacik 已提交
7615
	rsv->size = min_size;
7616
	rsv->failfast = 1;
7617

7618
	/*
7619
	 * 1 for the truncate slack space
7620 7621
	 * 1 for updating the inode.
	 */
7622
	trans = btrfs_start_transaction(root, 2);
7623 7624 7625 7626
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out;
	}
7627

7628 7629 7630
	/* Migrate the slack space for the truncate to our reserve */
	ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
				      min_size);
7631
	BUG_ON(ret);
7632

7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649
	/*
	 * 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.
	 */
7650 7651
	if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
					   &BTRFS_I(inode)->runtime_flags))
7652 7653
		btrfs_add_ordered_operation(trans, root, inode);

J
Josef Bacik 已提交
7654 7655 7656 7657 7658 7659 7660 7661
	/*
	 * 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);
7662
	trans->block_rsv = rsv;
7663

7664 7665 7666 7667
	while (1) {
		ret = btrfs_truncate_inode_items(trans, root, inode,
						 inode->i_size,
						 BTRFS_EXTENT_DATA_KEY);
7668
		if (ret != -ENOSPC) {
7669
			err = ret;
7670
			break;
7671
		}
C
Chris Mason 已提交
7672

7673
		trans->block_rsv = &root->fs_info->trans_block_rsv;
7674
		ret = btrfs_update_inode(trans, root, inode);
7675 7676 7677 7678
		if (ret) {
			err = ret;
			break;
		}
7679

7680
		btrfs_end_transaction(trans, root);
7681
		btrfs_btree_balance_dirty(root);
7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693

		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;
7694 7695 7696
	}

	if (ret == 0 && inode->i_nlink > 0) {
7697
		trans->block_rsv = root->orphan_block_rsv;
7698
		ret = btrfs_orphan_del(trans, inode);
7699 7700
		if (ret)
			err = ret;
7701 7702
	}

7703 7704 7705 7706 7707
	if (trans) {
		trans->block_rsv = &root->fs_info->trans_block_rsv;
		ret = btrfs_update_inode(trans, root, inode);
		if (ret && !err)
			err = ret;
7708

7709
		ret = btrfs_end_transaction(trans, root);
7710
		btrfs_btree_balance_dirty(root);
7711
	}
7712 7713 7714 7715

out:
	btrfs_free_block_rsv(root, rsv);

7716 7717
	if (ret && !err)
		err = ret;
7718

7719
	return err;
C
Chris Mason 已提交
7720 7721
}

C
Chris Mason 已提交
7722 7723 7724
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
7725
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
7726
			     struct btrfs_root *new_root, u64 new_dirid)
C
Chris Mason 已提交
7727 7728
{
	struct inode *inode;
7729
	int err;
7730
	u64 index = 0;
C
Chris Mason 已提交
7731

7732 7733 7734 7735
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
				new_dirid, new_dirid,
				S_IFDIR | (~current_umask() & S_IRWXUGO),
				&index);
7736
	if (IS_ERR(inode))
C
Christoph Hellwig 已提交
7737
		return PTR_ERR(inode);
C
Chris Mason 已提交
7738 7739 7740
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

M
Miklos Szeredi 已提交
7741
	set_nlink(inode, 1);
7742
	btrfs_i_size_write(inode, 0);
7743

7744
	err = btrfs_update_inode(trans, new_root, inode);
7745

7746
	iput(inode);
7747
	return err;
C
Chris Mason 已提交
7748 7749 7750 7751 7752
}

struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;
Y
Yan, Zheng 已提交
7753
	struct inode *inode;
C
Chris Mason 已提交
7754 7755 7756 7757

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
Y
Yan, Zheng 已提交
7758 7759 7760

	ei->root = NULL;
	ei->generation = 0;
7761
	ei->last_trans = 0;
7762
	ei->last_sub_trans = 0;
7763
	ei->logged_trans = 0;
Y
Yan, Zheng 已提交
7764 7765 7766
	ei->delalloc_bytes = 0;
	ei->disk_i_size = 0;
	ei->flags = 0;
7767
	ei->csum_bytes = 0;
Y
Yan, Zheng 已提交
7768 7769
	ei->index_cnt = (u64)-1;
	ei->last_unlink_trans = 0;
7770
	ei->last_log_commit = 0;
Y
Yan, Zheng 已提交
7771

7772 7773 7774
	spin_lock_init(&ei->lock);
	ei->outstanding_extents = 0;
	ei->reserved_extents = 0;
Y
Yan, Zheng 已提交
7775

7776
	ei->runtime_flags = 0;
7777
	ei->force_compress = BTRFS_COMPRESS_NONE;
Y
Yan, Zheng 已提交
7778

7779 7780
	ei->delayed_node = NULL;

Y
Yan, Zheng 已提交
7781
	inode = &ei->vfs_inode;
7782
	extent_map_tree_init(&ei->extent_tree);
7783 7784
	extent_io_tree_init(&ei->io_tree, &inode->i_data);
	extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
7785 7786
	ei->io_tree.track_uptodate = 1;
	ei->io_failure_tree.track_uptodate = 1;
7787
	atomic_set(&ei->sync_writers, 0);
Y
Yan, Zheng 已提交
7788
	mutex_init(&ei->log_mutex);
7789
	mutex_init(&ei->delalloc_mutex);
7790
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
Y
Yan, Zheng 已提交
7791
	INIT_LIST_HEAD(&ei->delalloc_inodes);
7792
	INIT_LIST_HEAD(&ei->ordered_operations);
Y
Yan, Zheng 已提交
7793 7794 7795
	RB_CLEAR_NODE(&ei->rb_node);

	return inode;
C
Chris Mason 已提交
7796 7797
}

N
Nick Piggin 已提交
7798 7799 7800 7801 7802 7803
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 已提交
7804 7805
void btrfs_destroy_inode(struct inode *inode)
{
7806
	struct btrfs_ordered_extent *ordered;
7807 7808
	struct btrfs_root *root = BTRFS_I(inode)->root;

A
Al Viro 已提交
7809
	WARN_ON(!hlist_empty(&inode->i_dentry));
C
Chris Mason 已提交
7810
	WARN_ON(inode->i_data.nrpages);
7811 7812
	WARN_ON(BTRFS_I(inode)->outstanding_extents);
	WARN_ON(BTRFS_I(inode)->reserved_extents);
7813 7814
	WARN_ON(BTRFS_I(inode)->delalloc_bytes);
	WARN_ON(BTRFS_I(inode)->csum_bytes);
C
Chris Mason 已提交
7815

7816 7817 7818 7819 7820 7821 7822 7823
	/*
	 * 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;

7824 7825 7826 7827 7828 7829
	/*
	 * Make sure we're properly removed from the ordered operation
	 * lists.
	 */
	smp_mb();
	if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
7830
		spin_lock(&root->fs_info->ordered_root_lock);
7831
		list_del_init(&BTRFS_I(inode)->ordered_operations);
7832
		spin_unlock(&root->fs_info->ordered_root_lock);
7833 7834
	}

7835 7836
	if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
		     &BTRFS_I(inode)->runtime_flags)) {
7837
		btrfs_info(root->fs_info, "inode %llu still on the orphan list",
7838
			btrfs_ino(inode));
7839
		atomic_dec(&root->orphan_inodes);
7840 7841
	}

C
Chris Mason 已提交
7842
	while (1) {
7843 7844 7845 7846
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
7847
			btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup",
7848
				ordered->file_offset, ordered->len);
7849 7850 7851 7852 7853
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
7854
	inode_tree_del(inode);
7855
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
7856
free:
N
Nick Piggin 已提交
7857
	call_rcu(&inode->i_rcu, btrfs_i_callback);
C
Chris Mason 已提交
7858 7859
}

7860
int btrfs_drop_inode(struct inode *inode)
7861 7862
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
7863

7864 7865 7866
	if (root == NULL)
		return 1;

7867
	/* the snap/subvol tree is on deleting */
7868
	if (btrfs_root_refs(&root->root_item) == 0)
7869
		return 1;
7870
	else
7871
		return generic_drop_inode(inode);
7872 7873
}

7874
static void init_once(void *foo)
C
Chris Mason 已提交
7875 7876 7877 7878 7879 7880 7881 7882
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
7883 7884 7885 7886 7887
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
C
Chris Mason 已提交
7888 7889 7890 7891 7892 7893 7894 7895
	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);
7896 7897
	if (btrfs_free_space_cachep)
		kmem_cache_destroy(btrfs_free_space_cachep);
7898 7899
	if (btrfs_delalloc_work_cachep)
		kmem_cache_destroy(btrfs_delalloc_work_cachep);
C
Chris Mason 已提交
7900 7901 7902 7903
}

int btrfs_init_cachep(void)
{
D
David Sterba 已提交
7904
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
7905 7906
			sizeof(struct btrfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
C
Chris Mason 已提交
7907 7908
	if (!btrfs_inode_cachep)
		goto fail;
7909

D
David Sterba 已提交
7910
	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
7911 7912
			sizeof(struct btrfs_trans_handle), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7913 7914
	if (!btrfs_trans_handle_cachep)
		goto fail;
7915

D
David Sterba 已提交
7916
	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
7917 7918
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7919 7920
	if (!btrfs_transaction_cachep)
		goto fail;
7921

D
David Sterba 已提交
7922
	btrfs_path_cachep = kmem_cache_create("btrfs_path",
7923 7924
			sizeof(struct btrfs_path), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7925 7926
	if (!btrfs_path_cachep)
		goto fail;
7927

D
David Sterba 已提交
7928
	btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
7929 7930 7931 7932 7933
			sizeof(struct btrfs_free_space), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
	if (!btrfs_free_space_cachep)
		goto fail;

7934 7935 7936 7937 7938 7939 7940
	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 已提交
7941 7942 7943 7944 7945 7946 7947 7948 7949
	return 0;
fail:
	btrfs_destroy_cachep();
	return -ENOMEM;
}

static int btrfs_getattr(struct vfsmount *mnt,
			 struct dentry *dentry, struct kstat *stat)
{
7950
	u64 delalloc_bytes;
C
Chris Mason 已提交
7951
	struct inode *inode = dentry->d_inode;
D
David Sterba 已提交
7952 7953
	u32 blocksize = inode->i_sb->s_blocksize;

C
Chris Mason 已提交
7954
	generic_fillattr(inode, stat);
7955
	stat->dev = BTRFS_I(inode)->root->anon_dev;
C
Chris Mason 已提交
7956
	stat->blksize = PAGE_CACHE_SIZE;
7957 7958 7959 7960

	spin_lock(&BTRFS_I(inode)->lock);
	delalloc_bytes = BTRFS_I(inode)->delalloc_bytes;
	spin_unlock(&BTRFS_I(inode)->lock);
D
David Sterba 已提交
7961
	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
7962
			ALIGN(delalloc_bytes, blocksize)) >> 9;
C
Chris Mason 已提交
7963 7964 7965
	return 0;
}

C
Chris Mason 已提交
7966 7967
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
7968 7969 7970
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
7971
	struct btrfs_root *dest = BTRFS_I(new_dir)->root;
C
Chris Mason 已提交
7972 7973 7974
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
7975
	u64 index = 0;
7976
	u64 root_objectid;
C
Chris Mason 已提交
7977
	int ret;
L
Li Zefan 已提交
7978
	u64 old_ino = btrfs_ino(old_inode);
C
Chris Mason 已提交
7979

L
Li Zefan 已提交
7980
	if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
7981 7982
		return -EPERM;

7983
	/* we only allow rename subvolume link between subvolumes */
L
Li Zefan 已提交
7984
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
7985 7986
		return -EXDEV;

L
Li Zefan 已提交
7987 7988
	if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
	    (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
C
Chris Mason 已提交
7989
		return -ENOTEMPTY;
7990

7991 7992 7993
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
		return -ENOTEMPTY;
C
Chris Mason 已提交
7994 7995 7996


	/* check for collisions, even if the  name isn't there */
7997
	ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino,
C
Chris Mason 已提交
7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015
			     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;

8016 8017 8018 8019 8020
	/*
	 * 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
	 */
8021
	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
8022 8023 8024
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

8025
	/* close the racy window with snapshot create/destroy ioctl */
L
Li Zefan 已提交
8026
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8027
		down_read(&root->fs_info->subvol_sem);
8028 8029 8030 8031 8032 8033 8034 8035
	/*
	 * 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.
	 */
8036
	trans = btrfs_start_transaction(root, 11);
8037 8038 8039 8040
	if (IS_ERR(trans)) {
                ret = PTR_ERR(trans);
                goto out_notrans;
        }
8041

8042 8043
	if (dest != root)
		btrfs_record_root_in_trans(trans, dest);
8044

8045 8046 8047
	ret = btrfs_set_inode_index(new_dir, &index);
	if (ret)
		goto out_fail;
8048

L
Li Zefan 已提交
8049
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8050 8051 8052
		/* force full log commit if subvolume involved. */
		root->fs_info->last_trans_log_full_commit = trans->transid;
	} else {
8053 8054 8055
		ret = btrfs_insert_inode_ref(trans, dest,
					     new_dentry->d_name.name,
					     new_dentry->d_name.len,
L
Li Zefan 已提交
8056 8057
					     old_ino,
					     btrfs_ino(new_dir), index);
8058 8059
		if (ret)
			goto out_fail;
8060 8061 8062 8063 8064 8065 8066 8067 8068
		/*
		 * 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);
	}
8069 8070 8071 8072
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
L
Li Zefan 已提交
8073
	if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
8074 8075
		btrfs_add_ordered_operation(trans, root, old_inode);

8076 8077 8078
	inode_inc_iversion(old_dir);
	inode_inc_iversion(new_dir);
	inode_inc_iversion(old_inode);
C
Chris Mason 已提交
8079 8080 8081
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
8082

8083 8084 8085
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

L
Li Zefan 已提交
8086
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8087 8088 8089 8090 8091
		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 {
8092 8093 8094 8095 8096 8097
		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);
8098
	}
8099 8100 8101 8102
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
8103 8104

	if (new_inode) {
8105
		inode_inc_iversion(new_inode);
C
Chris Mason 已提交
8106
		new_inode->i_ctime = CURRENT_TIME;
L
Li Zefan 已提交
8107
		if (unlikely(btrfs_ino(new_inode) ==
8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120
			     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);
		}
8121
		if (!ret && new_inode->i_nlink == 0)
8122
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
8123 8124 8125 8126
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_fail;
		}
C
Chris Mason 已提交
8127
	}
8128

8129 8130
	ret = btrfs_add_link(trans, new_dir, old_inode,
			     new_dentry->d_name.name,
8131
			     new_dentry->d_name.len, 0, index);
8132 8133 8134 8135
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
8136

L
Li Zefan 已提交
8137
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
8138
		struct dentry *parent = new_dentry->d_parent;
8139
		btrfs_log_new_name(trans, old_inode, old_dir, parent);
8140 8141
		btrfs_end_log_trans(root);
	}
C
Chris Mason 已提交
8142
out_fail:
8143
	btrfs_end_transaction(trans, root);
8144
out_notrans:
L
Li Zefan 已提交
8145
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8146
		up_read(&root->fs_info->subvol_sem);
J
Josef Bacik 已提交
8147

C
Chris Mason 已提交
8148 8149 8150
	return ret;
}

8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193
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 已提交
8194 8195 8196 8197
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
8198
static int __start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
8199 8200
{
	struct btrfs_inode *binode;
8201
	struct inode *inode;
8202 8203
	struct btrfs_delalloc_work *work, *next;
	struct list_head works;
8204
	struct list_head splice;
8205
	int ret = 0;
8206

8207
	INIT_LIST_HEAD(&works);
8208
	INIT_LIST_HEAD(&splice);
8209

8210 8211
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
8212 8213
	while (!list_empty(&splice)) {
		binode = list_entry(splice.next, struct btrfs_inode,
8214
				    delalloc_inodes);
8215

8216 8217
		list_move_tail(&binode->delalloc_inodes,
			       &root->delalloc_inodes);
8218
		inode = igrab(&binode->vfs_inode);
8219
		if (!inode) {
8220
			cond_resched_lock(&root->delalloc_lock);
8221
			continue;
8222
		}
8223
		spin_unlock(&root->delalloc_lock);
8224 8225 8226

		work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
		if (unlikely(!work)) {
8227 8228 8229 8230
			if (delay_iput)
				btrfs_add_delayed_iput(inode);
			else
				iput(inode);
8231 8232
			ret = -ENOMEM;
			goto out;
8233
		}
8234 8235 8236 8237
		list_add_tail(&work->list, &works);
		btrfs_queue_worker(&root->fs_info->flush_workers,
				   &work->work);

8238
		cond_resched();
8239
		spin_lock(&root->delalloc_lock);
8240
	}
8241
	spin_unlock(&root->delalloc_lock);
8242

8243 8244 8245 8246
	list_for_each_entry_safe(work, next, &works, list) {
		list_del_init(&work->list);
		btrfs_wait_and_free_delalloc_work(work);
	}
8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260
	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;
}
8261

8262 8263 8264
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
{
	int ret;
8265

8266 8267 8268 8269 8270 8271
	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
8272 8273 8274 8275
	 * 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 已提交
8276
	while (atomic_read(&root->fs_info->nr_async_submits) ||
8277
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
8278
		wait_event(root->fs_info->async_submit_wait,
8279 8280
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
8281 8282
	}
	atomic_dec(&root->fs_info->async_submit_draining);
8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314
	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);
8315
	}
8316
	spin_unlock(&fs_info->delalloc_root_lock);
8317

8318 8319 8320 8321 8322 8323 8324 8325 8326 8327
	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:
8328
	if (!list_empty_careful(&splice)) {
8329 8330 8331
		spin_lock(&fs_info->delalloc_root_lock);
		list_splice_tail(&splice, &fs_info->delalloc_roots);
		spin_unlock(&fs_info->delalloc_root_lock);
8332
	}
8333
	return ret;
8334 8335
}

C
Chris Mason 已提交
8336 8337 8338 8339 8340 8341 8342
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;
8343
	struct inode *inode = NULL;
C
Chris Mason 已提交
8344 8345 8346
	int err;
	int drop_inode = 0;
	u64 objectid;
8347
	u64 index = 0 ;
C
Chris Mason 已提交
8348 8349
	int name_len;
	int datasize;
8350
	unsigned long ptr;
C
Chris Mason 已提交
8351
	struct btrfs_file_extent_item *ei;
8352
	struct extent_buffer *leaf;
C
Chris Mason 已提交
8353

8354
	name_len = strlen(symname);
C
Chris Mason 已提交
8355 8356
	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
		return -ENAMETOOLONG;
8357

J
Josef Bacik 已提交
8358 8359 8360 8361 8362
	/*
	 * 2 items for inode item and ref
	 * 2 items for dir items
	 * 1 item for xattr if selinux is on
	 */
8363 8364 8365
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
8366

8367 8368 8369 8370
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

8371
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
L
Li Zefan 已提交
8372
				dentry->d_name.len, btrfs_ino(dir), objectid,
8373
				S_IFLNK|S_IRWXUGO, &index);
8374 8375
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
8376
		goto out_unlock;
8377
	}
C
Chris Mason 已提交
8378

8379
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
8380 8381 8382 8383 8384
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

8385 8386 8387 8388 8389 8390 8391 8392 8393
	/*
	* 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;

8394
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
8395 8396 8397 8398
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
8399
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
8400
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
8401 8402 8403 8404 8405
	}
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
8406 8407 8408 8409 8410
	if (!path) {
		err = -ENOMEM;
		drop_inode = 1;
		goto out_unlock;
	}
L
Li Zefan 已提交
8411
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
8412 8413 8414 8415 8416
	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);
8417 8418
	if (err) {
		drop_inode = 1;
8419
		btrfs_free_path(path);
8420 8421
		goto out_unlock;
	}
8422 8423 8424 8425 8426
	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 已提交
8427
				   BTRFS_FILE_EXTENT_INLINE);
C
Chris Mason 已提交
8428 8429 8430 8431 8432
	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 已提交
8433
	ptr = btrfs_file_extent_inline_start(ei);
8434 8435
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
8436
	btrfs_free_path(path);
8437

C
Chris Mason 已提交
8438 8439
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
8440
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
Y
Yan Zheng 已提交
8441
	inode_set_bytes(inode, name_len);
8442
	btrfs_i_size_write(inode, name_len);
8443 8444 8445
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
8446 8447

out_unlock:
8448 8449
	if (!err)
		d_instantiate(dentry, inode);
8450
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
8451 8452 8453 8454
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
8455
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
8456 8457
	return err;
}
8458

8459 8460 8461 8462
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 已提交
8463
{
J
Josef Bacik 已提交
8464 8465
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
Y
Yan Zheng 已提交
8466 8467 8468
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 cur_offset = start;
8469
	u64 i_size;
8470
	u64 cur_bytes;
Y
Yan Zheng 已提交
8471
	int ret = 0;
8472
	bool own_trans = true;
Y
Yan Zheng 已提交
8473

8474 8475
	if (trans)
		own_trans = false;
Y
Yan Zheng 已提交
8476
	while (num_bytes > 0) {
8477 8478 8479 8480 8481 8482
		if (own_trans) {
			trans = btrfs_start_transaction(root, 3);
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				break;
			}
8483 8484
		}

8485 8486
		cur_bytes = min(num_bytes, 256ULL * 1024 * 1024);
		cur_bytes = max(cur_bytes, min_size);
8487 8488
		ret = btrfs_reserve_extent(root, cur_bytes, min_size, 0,
					   *alloc_hint, &ins, 1);
8489
		if (ret) {
8490 8491
			if (own_trans)
				btrfs_end_transaction(trans, root);
8492
			break;
Y
Yan Zheng 已提交
8493
		}
8494

Y
Yan Zheng 已提交
8495 8496 8497
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
Y
Yan, Zheng 已提交
8498
						  ins.offset, 0, 0, 0,
Y
Yan Zheng 已提交
8499
						  BTRFS_FILE_EXTENT_PREALLOC);
8500 8501 8502 8503 8504 8505
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
C
Chris Mason 已提交
8506 8507
		btrfs_drop_extent_cache(inode, cur_offset,
					cur_offset + ins.offset -1, 0);
8508

J
Josef Bacik 已提交
8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520
		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;
8521
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
8522
		em->ram_bytes = ins.offset;
J
Josef Bacik 已提交
8523 8524 8525 8526 8527 8528
		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 已提交
8529
			ret = add_extent_mapping(em_tree, em, 1);
J
Josef Bacik 已提交
8530 8531 8532 8533 8534 8535 8536 8537 8538
			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 已提交
8539 8540
		num_bytes -= ins.offset;
		cur_offset += ins.offset;
8541
		*alloc_hint = ins.objectid + ins.offset;
8542

8543
		inode_inc_iversion(inode);
Y
Yan Zheng 已提交
8544
		inode->i_ctime = CURRENT_TIME;
8545
		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
Y
Yan Zheng 已提交
8546
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
8547 8548
		    (actual_len > inode->i_size) &&
		    (cur_offset > inode->i_size)) {
8549
			if (cur_offset > actual_len)
8550
				i_size = actual_len;
8551
			else
8552 8553 8554
				i_size = cur_offset;
			i_size_write(inode, i_size);
			btrfs_ordered_update_i_size(inode, i_size, NULL);
8555 8556
		}

Y
Yan Zheng 已提交
8557
		ret = btrfs_update_inode(trans, root, inode);
8558 8559 8560 8561 8562 8563 8564

		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
Y
Yan Zheng 已提交
8565

8566 8567
		if (own_trans)
			btrfs_end_transaction(trans, root);
8568
	}
Y
Yan Zheng 已提交
8569 8570 8571
	return ret;
}

8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589
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);
}

8590 8591 8592 8593 8594
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

8595
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
8596
{
L
Li Zefan 已提交
8597
	struct btrfs_root *root = BTRFS_I(inode)->root;
8598
	umode_t mode = inode->i_mode;
L
Li Zefan 已提交
8599

8600 8601 8602 8603 8604 8605 8606
	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;
	}
8607
	return generic_permission(inode, mask);
Y
Yan 已提交
8608
}
C
Chris Mason 已提交
8609

8610
static const struct inode_operations btrfs_dir_inode_operations = {
8611
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
8612 8613 8614 8615 8616 8617 8618 8619 8620
	.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 已提交
8621
	.mknod		= btrfs_mknod,
8622 8623
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8624
	.listxattr	= btrfs_listxattr,
8625
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
8626
	.permission	= btrfs_permission,
8627
	.get_acl	= btrfs_get_acl,
8628
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8629
};
8630
static const struct inode_operations btrfs_dir_ro_inode_operations = {
C
Chris Mason 已提交
8631
	.lookup		= btrfs_lookup,
Y
Yan 已提交
8632
	.permission	= btrfs_permission,
8633
	.get_acl	= btrfs_get_acl,
8634
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8635
};
8636

8637
static const struct file_operations btrfs_dir_file_operations = {
C
Chris Mason 已提交
8638 8639
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
A
Al Viro 已提交
8640
	.iterate	= btrfs_real_readdir,
C
Christoph Hellwig 已提交
8641
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
8642
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
8643
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
8644
#endif
S
Sage Weil 已提交
8645
	.release        = btrfs_release_file,
8646
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
8647 8648
};

8649
static struct extent_io_ops btrfs_extent_io_ops = {
8650
	.fill_delalloc = run_delalloc_range,
8651
	.submit_bio_hook = btrfs_submit_bio_hook,
8652
	.merge_bio_hook = btrfs_merge_bio_hook,
8653
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
8654
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
8655
	.writepage_start_hook = btrfs_writepage_start_hook,
C
Chris Mason 已提交
8656 8657
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
J
Josef Bacik 已提交
8658 8659
	.merge_extent_hook = btrfs_merge_extent_hook,
	.split_extent_hook = btrfs_split_extent_hook,
8660 8661
};

8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673
/*
 * 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.
 */
8674
static const struct address_space_operations btrfs_aops = {
C
Chris Mason 已提交
8675 8676
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
8677
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
8678
	.readpages	= btrfs_readpages,
8679
	.direct_IO	= btrfs_direct_IO,
8680 8681
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
8682
	.set_page_dirty	= btrfs_set_page_dirty,
8683
	.error_remove_page = generic_error_remove_page,
C
Chris Mason 已提交
8684 8685
};

8686
static const struct address_space_operations btrfs_symlink_aops = {
C
Chris Mason 已提交
8687 8688
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
8689 8690
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
8691 8692
};

8693
static const struct inode_operations btrfs_file_inode_operations = {
C
Chris Mason 已提交
8694 8695
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
8696 8697
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8698
	.listxattr      = btrfs_listxattr,
8699
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
8700
	.permission	= btrfs_permission,
Y
Yehuda Sadeh 已提交
8701
	.fiemap		= btrfs_fiemap,
8702
	.get_acl	= btrfs_get_acl,
8703
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8704
};
8705
static const struct inode_operations btrfs_special_inode_operations = {
J
Josef Bacik 已提交
8706 8707
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
8708
	.permission	= btrfs_permission,
8709 8710
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
8711
	.listxattr	= btrfs_listxattr,
8712
	.removexattr	= btrfs_removexattr,
8713
	.get_acl	= btrfs_get_acl,
8714
	.update_time	= btrfs_update_time,
J
Josef Bacik 已提交
8715
};
8716
static const struct inode_operations btrfs_symlink_inode_operations = {
C
Chris Mason 已提交
8717 8718 8719
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
8720
	.getattr	= btrfs_getattr,
8721
	.setattr	= btrfs_setattr,
Y
Yan 已提交
8722
	.permission	= btrfs_permission,
J
Jim Owens 已提交
8723 8724 8725 8726
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
8727
	.get_acl	= btrfs_get_acl,
8728
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
8729
};
8730

8731
const struct dentry_operations btrfs_dentry_operations = {
8732
	.d_delete	= btrfs_dentry_delete,
8733
	.d_release	= btrfs_dentry_release,
8734
};