inode.c 210.5 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/bit_spinlock.h>
J
Josef Bacik 已提交
36
#include <linux/xattr.h>
J
Josef Bacik 已提交
37
#include <linux/posix_acl.h>
38
#include <linux/falloc.h>
39
#include <linux/slab.h>
40
#include <linux/ratelimit.h>
41
#include <linux/mount.h>
C
Chris Mason 已提交
42
#include "compat.h"
C
Chris Mason 已提交
43 44 45 46 47 48
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"
49
#include "ordered-data.h"
50
#include "xattr.h"
51
#include "tree-log.h"
52
#include "volumes.h"
53
#include "compression.h"
54
#include "locking.h"
55
#include "free-space-cache.h"
56
#include "inode-map.h"
C
Chris Mason 已提交
57 58 59 60 61 62

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

63 64 65 66 67
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;
68 69
static const struct address_space_operations btrfs_aops;
static const struct address_space_operations btrfs_symlink_aops;
70
static const struct file_operations btrfs_dir_file_operations;
71
static struct extent_io_ops btrfs_extent_io_ops;
C
Chris Mason 已提交
72 73

static struct kmem_cache *btrfs_inode_cachep;
74
static struct kmem_cache *btrfs_delalloc_work_cachep;
C
Chris Mason 已提交
75 76 77
struct kmem_cache *btrfs_trans_handle_cachep;
struct kmem_cache *btrfs_transaction_cachep;
struct kmem_cache *btrfs_path_cachep;
78
struct kmem_cache *btrfs_free_space_cachep;
C
Chris Mason 已提交
79 80 81 82 83 84 85 86 87 88 89 90

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

91 92
static int btrfs_setsize(struct inode *inode, loff_t newsize);
static int btrfs_truncate(struct inode *inode);
93
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
94 95 96 97
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);
98 99 100 101
static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
					   u64 len, u64 orig_start,
					   u64 block_start, u64 block_len,
					   u64 orig_block_len, int type);
102

103
static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
104 105
				     struct inode *inode,  struct inode *dir,
				     const struct qstr *qstr)
J
Jim Owens 已提交
106 107 108
{
	int err;

109
	err = btrfs_init_acl(trans, inode, dir);
J
Jim Owens 已提交
110
	if (!err)
111
		err = btrfs_xattr_security_init(trans, inode, dir, qstr);
J
Jim Owens 已提交
112 113 114
	return err;
}

115 116 117 118 119
/*
 * 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
 */
120
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
121 122
				struct btrfs_root *root, struct inode *inode,
				u64 start, size_t size, size_t compressed_size,
123
				int compress_type,
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
				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;

139
	if (compressed_size && compressed_pages)
140 141
		cur_size = compressed_size;

142 143
	path = btrfs_alloc_path();
	if (!path)
144 145
		return -ENOMEM;

146
	path->leave_spinning = 1;
147

148
	key.objectid = btrfs_ino(inode);
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
	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);

170
	if (compress_type != BTRFS_COMPRESS_NONE) {
171 172
		struct page *cpage;
		int i = 0;
173
		while (compressed_size > 0) {
174
			cpage = compressed_pages[i];
175
			cur_size = min_t(unsigned long, compressed_size,
176 177
				       PAGE_CACHE_SIZE);

178
			kaddr = kmap_atomic(cpage);
179
			write_extent_buffer(leaf, kaddr, ptr, cur_size);
180
			kunmap_atomic(kaddr);
181 182 183 184 185 186

			i++;
			ptr += cur_size;
			compressed_size -= cur_size;
		}
		btrfs_set_file_extent_compression(leaf, ei,
187
						  compress_type);
188 189 190 191
	} else {
		page = find_get_page(inode->i_mapping,
				     start >> PAGE_CACHE_SHIFT);
		btrfs_set_file_extent_compression(leaf, ei, 0);
192
		kaddr = kmap_atomic(page);
193 194
		offset = start & (PAGE_CACHE_SIZE - 1);
		write_extent_buffer(leaf, kaddr + offset, ptr, size);
195
		kunmap_atomic(kaddr);
196 197 198 199 200
		page_cache_release(page);
	}
	btrfs_mark_buffer_dirty(leaf);
	btrfs_free_path(path);

201 202 203 204 205 206 207 208 209
	/*
	 * 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.
	 */
210
	BTRFS_I(inode)->disk_i_size = inode->i_size;
211
	ret = btrfs_update_inode(trans, root, inode);
212

213
	return ret;
214 215 216 217 218 219 220 221 222 223 224
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.
 */
225
static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
226 227
				 struct btrfs_root *root,
				 struct inode *inode, u64 start, u64 end,
228
				 size_t compressed_size, int compress_type,
229 230 231 232 233 234 235 236 237 238 239 240 241 242
				 struct page **compressed_pages)
{
	u64 isize = i_size_read(inode);
	u64 actual_end = min(end + 1, isize);
	u64 inline_len = actual_end - start;
	u64 aligned_end = (end + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
	u64 data_len = inline_len;
	int ret;

	if (compressed_size)
		data_len = compressed_size;

	if (start > 0 ||
243
	    actual_end >= PAGE_CACHE_SIZE ||
244 245 246 247 248 249 250 251
	    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;
	}

252
	ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
253 254
	if (ret)
		return ret;
255 256 257 258 259

	if (isize > actual_end)
		inline_len = min_t(u64, isize, actual_end);
	ret = insert_inline_extent(trans, root, inode, start,
				   inline_len, compressed_size,
260
				   compress_type, compressed_pages);
261
	if (ret && ret != -ENOSPC) {
262 263
		btrfs_abort_transaction(trans, root, ret);
		return ret;
264 265
	} else if (ret == -ENOSPC) {
		return 1;
266
	}
267

268
	btrfs_delalloc_release_metadata(inode, end + 1 - start);
269
	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
270 271 272
	return 0;
}

273 274 275 276 277 278
struct async_extent {
	u64 start;
	u64 ram_size;
	u64 compressed_size;
	struct page **pages;
	unsigned long nr_pages;
279
	int compress_type;
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	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,
297 298
				     unsigned long nr_pages,
				     int compress_type)
299 300 301 302
{
	struct async_extent *async_extent;

	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
303
	BUG_ON(!async_extent); /* -ENOMEM */
304 305 306 307 308
	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;
309
	async_extent->compress_type = compress_type;
310 311 312 313
	list_add_tail(&async_extent->list, &cow->extents);
	return 0;
}

314
/*
315 316 317
 * 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).
318
 *
319 320 321 322 323
 * 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.
324
 *
325 326 327
 * 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
328 329
 * are written in the same order that the flusher thread sent them
 * down.
330
 */
331 332 333 334 335
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)
336 337 338
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
339 340
	u64 num_bytes;
	u64 blocksize = root->sectorsize;
341
	u64 actual_end;
342
	u64 isize = i_size_read(inode);
343
	int ret = 0;
344 345 346 347 348 349
	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;
350
	unsigned long max_uncompressed = 128 * 1024;
351 352
	int i;
	int will_compress;
353
	int compress_type = root->fs_info->compress_type;
354

355 356 357
	/* 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))
358 359
		btrfs_add_inode_defrag(NULL, inode);

360
	actual_end = min_t(u64, isize, end + 1);
361 362 363 364
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);
365

366 367 368 369 370 371 372 373 374 375 376 377 378
	/*
	 * 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;

379 380 381 382
	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
383 384 385 386 387 388 389
	 * 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.
390 391
	 */
	total_compressed = min(total_compressed, max_uncompressed);
392
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
393
	num_bytes = max(blocksize,  num_bytes);
394 395
	total_in = 0;
	ret = 0;
396

397 398 399 400
	/*
	 * 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.
401
	 */
402
	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
403
	    (btrfs_test_opt(root, COMPRESS) ||
404 405
	     (BTRFS_I(inode)->force_compress) ||
	     (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
406
		WARN_ON(pages);
407
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
408 409 410 411
		if (!pages) {
			/* just bail out to the uncompressed code */
			goto cont;
		}
412

413 414 415 416 417 418 419 420 421 422
		if (BTRFS_I(inode)->force_compress)
			compress_type = BTRFS_I(inode)->force_compress;

		ret = btrfs_compress_pages(compress_type,
					   inode->i_mapping, start,
					   total_compressed, pages,
					   nr_pages, &nr_pages_ret,
					   &total_in,
					   &total_compressed,
					   max_compressed);
423 424 425 426 427 428 429 430 431 432 433

		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) {
434
				kaddr = kmap_atomic(page);
435 436
				memset(kaddr + offset, 0,
				       PAGE_CACHE_SIZE - offset);
437
				kunmap_atomic(kaddr);
438 439 440 441
			}
			will_compress = 1;
		}
	}
442
cont:
443
	if (start == 0) {
444
		trans = btrfs_join_transaction(root);
445 446 447 448 449
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
			trans = NULL;
			goto cleanup_and_out;
		}
450
		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
451

452
		/* lets try to make an inline extent */
453
		if (ret || total_in < (actual_end - start)) {
454
			/* we didn't compress the entire range, try
455
			 * to make an uncompressed inline extent.
456 457
			 */
			ret = cow_file_range_inline(trans, root, inode,
458
						    start, end, 0, 0, NULL);
459
		} else {
460
			/* try making a compressed inline extent */
461 462
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
463 464
						    total_compressed,
						    compress_type, pages);
465
		}
466
		if (ret <= 0) {
467
			/*
468 469 470
			 * 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.
471
			 */
472
			extent_clear_unlock_delalloc(inode,
473 474 475
			     &BTRFS_I(inode)->io_tree,
			     start, end, NULL,
			     EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
476
			     EXTENT_CLEAR_DELALLOC |
477
			     EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
478 479

			btrfs_end_transaction(trans, root);
480 481
			goto free_pages_out;
		}
482
		btrfs_end_transaction(trans, root);
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
	}

	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
		 */
		total_compressed = (total_compressed + blocksize - 1) &
			~(blocksize - 1);

		/*
		 * one last check to make sure the compression is really a
		 * win, compare the page count read with the blocks on disk
		 */
		total_in = (total_in + PAGE_CACHE_SIZE - 1) &
			~(PAGE_CACHE_SIZE - 1);
		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++) {
512
			WARN_ON(pages[i]->mapping);
513 514 515 516 517 518 519 520
			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 */
521 522
		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
		    !(BTRFS_I(inode)->force_compress)) {
523
			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
524
		}
525
	}
526 527
	if (will_compress) {
		*num_added += 1;
528

529 530 531 532 533
		/* 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,
534 535
				 total_compressed, pages, nr_pages_ret,
				 compress_type);
536

537
		if (start + num_bytes < end) {
538 539 540 541 542 543
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
544
cleanup_and_bail_uncompressed:
545 546 547 548 549 550 551 552 553 554 555 556
		/*
		 * 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 */
		}
557 558
		add_async_extent(async_cow, start, end - start + 1,
				 0, NULL, 0, BTRFS_COMPRESS_NONE);
559 560
		*num_added += 1;
	}
561

562
out:
563
	return ret;
564 565 566 567 568 569

free_pages_out:
	for (i = 0; i < nr_pages_ret; i++) {
		WARN_ON(pages[i]->mapping);
		page_cache_release(pages[i]);
	}
570
	kfree(pages);
571 572

	goto out;
573 574 575 576 577 578 579 580 581 582 583 584 585 586

cleanup_and_out:
	extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
				     start, end, NULL,
				     EXTENT_CLEAR_UNLOCK_PAGE |
				     EXTENT_CLEAR_DIRTY |
				     EXTENT_CLEAR_DELALLOC |
				     EXTENT_SET_WRITEBACK |
				     EXTENT_END_WRITEBACK);
	if (!trans || IS_ERR(trans))
		btrfs_error(root->fs_info, ret, "Failed to join transaction");
	else
		btrfs_abort_transaction(trans, root, ret);
	goto free_pages_out;
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
}

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

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


612
	while (!list_empty(&async_cow->extents)) {
613 614 615
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
616

617 618
		io_tree = &BTRFS_I(inode)->io_tree;

619
retry:
620 621 622 623 624 625
		/* 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,
626
					 async_extent->start +
627
					 async_extent->ram_size - 1);
628 629

			/* allocate blocks */
630 631 632 633 634
			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);
635

636 637
			/* JDM XXX */

638 639 640 641 642 643
			/*
			 * 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.
			 */
644
			if (!page_started && !ret)
645 646
				extent_write_locked_range(io_tree,
						  inode, async_extent->start,
647
						  async_extent->start +
648 649 650 651 652 653 654 655 656
						  async_extent->ram_size - 1,
						  btrfs_get_extent,
						  WB_SYNC_ALL);
			kfree(async_extent);
			cond_resched();
			continue;
		}

		lock_extent(io_tree, async_extent->start,
657
			    async_extent->start + async_extent->ram_size - 1);
658

659
		trans = btrfs_join_transaction(root);
660 661 662 663 664
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
		} else {
			trans->block_rsv = &root->fs_info->delalloc_block_rsv;
			ret = btrfs_reserve_extent(trans, root,
665 666
					   async_extent->compressed_size,
					   async_extent->compressed_size,
667
					   0, alloc_hint, &ins, 1);
668
			if (ret && ret != -ENOSPC)
669 670 671
				btrfs_abort_transaction(trans, root, ret);
			btrfs_end_transaction(trans, root);
		}
672

673 674 675 676 677 678 679 680 681 682 683
		if (ret) {
			int i;
			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;
			unlock_extent(io_tree, async_extent->start,
				      async_extent->start +
684
				      async_extent->ram_size - 1);
685 686 687
			if (ret == -ENOSPC)
				goto retry;
			goto out_free; /* JDM: Requeue? */
688 689
		}

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

698
		em = alloc_extent_map();
699
		BUG_ON(!em); /* -ENOMEM */
700 701
		em->start = async_extent->start;
		em->len = async_extent->ram_size;
702
		em->orig_start = em->start;
703

704 705
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
706
		em->orig_block_len = ins.offset;
707
		em->bdev = root->fs_info->fs_devices->latest_bdev;
708
		em->compress_type = async_extent->compress_type;
709 710
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
711
		em->generation = -1;
712

713
		while (1) {
714
			write_lock(&em_tree->lock);
715
			ret = add_extent_mapping(em_tree, em);
716 717 718
			if (!ret)
				list_move(&em->list,
					  &em_tree->modified_extents);
719
			write_unlock(&em_tree->lock);
720 721 722 723 724 725 726 727 728
			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);
		}

729 730 731 732 733 734 735
		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);
736
		BUG_ON(ret); /* -ENOMEM */
737 738 739 740 741

		/*
		 * clear dirty, set writeback and unlock the pages.
		 */
		extent_clear_unlock_delalloc(inode,
742 743 744 745 746 747
				&BTRFS_I(inode)->io_tree,
				async_extent->start,
				async_extent->start +
				async_extent->ram_size - 1,
				NULL, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK |
748
				EXTENT_CLEAR_DELALLOC |
749
				EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
750 751

		ret = btrfs_submit_compressed_write(inode,
752 753 754 755 756
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
757

758
		BUG_ON(ret); /* -ENOMEM */
759 760 761 762
		alloc_hint = ins.objectid + ins.offset;
		kfree(async_extent);
		cond_resched();
	}
763 764 765 766 767 768
	ret = 0;
out:
	return ret;
out_free:
	kfree(async_extent);
	goto out;
769 770
}

771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
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;
}

803 804 805 806 807 808 809 810 811 812 813 814 815
/*
 * 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.
 */
816 817 818 819 820 821 822
static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
				     struct inode *inode,
				     struct btrfs_root *root,
				     struct page *locked_page,
				     u64 start, u64 end, int *page_started,
				     unsigned long *nr_written,
				     int unlock)
823 824 825 826 827 828 829 830 831 832 833 834
{
	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;

835
	BUG_ON(btrfs_is_free_space_inode(inode));
836 837 838 839 840

	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
	num_bytes = max(blocksize,  num_bytes);
	disk_num_bytes = num_bytes;

841
	/* if this is a small write inside eof, kick off defrag */
842 843
	if (num_bytes < 64 * 1024 &&
	    (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
844 845
		btrfs_add_inode_defrag(trans, inode);

846 847 848
	if (start == 0) {
		/* lets try to make an inline extent */
		ret = cow_file_range_inline(trans, root, inode,
849
					    start, end, 0, 0, NULL);
850 851
		if (ret == 0) {
			extent_clear_unlock_delalloc(inode,
852 853 854 855 856 857 858 859
				     &BTRFS_I(inode)->io_tree,
				     start, end, NULL,
				     EXTENT_CLEAR_UNLOCK_PAGE |
				     EXTENT_CLEAR_UNLOCK |
				     EXTENT_CLEAR_DELALLOC |
				     EXTENT_CLEAR_DIRTY |
				     EXTENT_SET_WRITEBACK |
				     EXTENT_END_WRITEBACK);
860

861 862 863 864
			*nr_written = *nr_written +
			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
			*page_started = 1;
			goto out;
865 866 867
		} else if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_unlock;
868 869 870 871
		}
	}

	BUG_ON(disk_num_bytes >
872
	       btrfs_super_total_bytes(root->fs_info->super_copy));
873

874
	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
875 876
	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

877
	while (disk_num_bytes > 0) {
878 879
		unsigned long op;

880
		cur_alloc_size = disk_num_bytes;
881
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
882
					   root->sectorsize, 0, alloc_hint,
883
					   &ins, 1);
884 885 886 887
		if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_unlock;
		}
888

889
		em = alloc_extent_map();
890
		BUG_ON(!em); /* -ENOMEM */
891
		em->start = start;
892
		em->orig_start = em->start;
893 894
		ram_size = ins.offset;
		em->len = ins.offset;
895

896
		em->block_start = ins.objectid;
897
		em->block_len = ins.offset;
898
		em->orig_block_len = ins.offset;
899
		em->bdev = root->fs_info->fs_devices->latest_bdev;
900
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
901
		em->generation = -1;
902

903
		while (1) {
904
			write_lock(&em_tree->lock);
905
			ret = add_extent_mapping(em_tree, em);
906 907 908
			if (!ret)
				list_move(&em->list,
					  &em_tree->modified_extents);
909
			write_unlock(&em_tree->lock);
910 911 912 913 914
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, start,
915
						start + ram_size - 1, 0);
916 917
		}

918
		cur_alloc_size = ins.offset;
919
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
920
					       ram_size, cur_alloc_size, 0);
921
		BUG_ON(ret); /* -ENOMEM */
922

923 924 925 926
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, start,
						      cur_alloc_size);
927 928 929 930
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto out_unlock;
			}
931 932
		}

933
		if (disk_num_bytes < cur_alloc_size)
934
			break;
935

936 937 938
		/* 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
939 940 941
		 *
		 * Do set the Private2 bit so we know this page was properly
		 * setup for writepage
942
		 */
943 944 945 946
		op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
		op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
			EXTENT_SET_PRIVATE2;

947 948
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					     start, start + ram_size - 1,
949
					     locked_page, op);
950
		disk_num_bytes -= cur_alloc_size;
951 952 953
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
954
	}
955
out:
956
	return ret;
957

958 959 960
out_unlock:
	extent_clear_unlock_delalloc(inode,
		     &BTRFS_I(inode)->io_tree,
961
		     start, end, locked_page,
962 963 964 965 966 967 968 969
		     EXTENT_CLEAR_UNLOCK_PAGE |
		     EXTENT_CLEAR_UNLOCK |
		     EXTENT_CLEAR_DELALLOC |
		     EXTENT_CLEAR_DIRTY |
		     EXTENT_SET_WRITEBACK |
		     EXTENT_END_WRITEBACK);

	goto out;
970
}
971

972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
static noinline int cow_file_range(struct inode *inode,
				   struct page *locked_page,
				   u64 start, u64 end, int *page_started,
				   unsigned long *nr_written,
				   int unlock)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

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

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

	btrfs_end_transaction(trans, root);

	return ret;
}

1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
/*
 * 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);
1017
	if (num_added == 0) {
1018
		btrfs_add_delayed_iput(async_cow->inode);
1019
		async_cow->inode = NULL;
1020
	}
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
}

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

1038
	if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
1039
	    5 * 1024 * 1024 &&
1040 1041 1042
	    waitqueue_active(&root->fs_info->async_submit_wait))
		wake_up(&root->fs_info->async_submit_wait);

1043
	if (async_cow->inode)
1044 1045
		submit_compressed_extents(async_cow->inode, async_cow);
}
1046

1047 1048 1049 1050
static noinline void async_cow_free(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	async_cow = container_of(work, struct async_cow, work);
1051
	if (async_cow->inode)
1052
		btrfs_add_delayed_iput(async_cow->inode);
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
	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;
1064
	int limit = 10 * 1024 * 1024;
1065

1066 1067
	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
			 1, 0, NULL, GFP_NOFS);
1068
	while (start < end) {
1069
		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
1070
		BUG_ON(!async_cow); /* -ENOMEM */
1071
		async_cow->inode = igrab(inode);
1072 1073 1074 1075
		async_cow->root = root;
		async_cow->locked_page = locked_page;
		async_cow->start = start;

1076
		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
			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));
		}

1102
		while (atomic_read(&root->fs_info->async_submit_draining) &&
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
		      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;
1114 1115
}

1116
static noinline int csum_exist_in_range(struct btrfs_root *root,
1117 1118 1119 1120 1121 1122
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

1123
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
A
Arne Jansen 已提交
1124
				       bytenr + num_bytes - 1, &list, 0);
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
	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;
}

1136 1137 1138 1139 1140 1141 1142
/*
 * 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
 */
1143 1144
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
1145 1146
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
1147 1148
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1149
	struct btrfs_trans_handle *trans;
1150 1151
	struct extent_buffer *leaf;
	struct btrfs_path *path;
1152
	struct btrfs_file_extent_item *fi;
1153
	struct btrfs_key found_key;
1154 1155 1156
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
1157
	u64 extent_offset;
1158 1159
	u64 disk_bytenr;
	u64 num_bytes;
1160
	u64 disk_num_bytes;
1161
	int extent_type;
1162
	int ret, err;
1163
	int type;
1164 1165
	int nocow;
	int check_prev = 1;
1166
	bool nolock;
1167
	u64 ino = btrfs_ino(inode);
1168 1169

	path = btrfs_alloc_path();
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
	if (!path) {
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     start, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);
1180
		return -ENOMEM;
1181
	}
1182

1183
	nolock = btrfs_is_free_space_inode(inode);
1184 1185

	if (nolock)
1186
		trans = btrfs_join_transaction_nolock(root);
1187
	else
1188
		trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
1189

1190
	if (IS_ERR(trans)) {
1191 1192 1193 1194 1195 1196 1197 1198 1199
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     start, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);
1200 1201 1202 1203
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}

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

1206 1207 1208
	cow_start = (u64)-1;
	cur_offset = start;
	while (1) {
1209
		ret = btrfs_lookup_file_extent(trans, root, path, ino,
1210
					       cur_offset, 0);
1211 1212 1213 1214
		if (ret < 0) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
1215 1216 1217 1218
		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);
1219
			if (found_key.objectid == ino &&
1220 1221 1222 1223 1224 1225 1226 1227
			    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);
1228 1229 1230 1231
			if (ret < 0) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
1232 1233 1234 1235
			if (ret > 0)
				break;
			leaf = path->nodes[0];
		}
1236

1237 1238
		nocow = 0;
		disk_bytenr = 0;
1239
		num_bytes = 0;
1240 1241
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

1242
		if (found_key.objectid > ino ||
1243 1244 1245 1246 1247 1248
		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
		    found_key.offset > end)
			break;

		if (found_key.offset > cur_offset) {
			extent_end = found_key.offset;
1249
			extent_type = 0;
1250 1251 1252 1253 1254 1255 1256
			goto out_check;
		}

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

1257 1258
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1259
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1260
			extent_offset = btrfs_file_extent_offset(leaf, fi);
1261 1262
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
1263 1264
			disk_num_bytes =
				btrfs_file_extent_disk_num_bytes(leaf, fi);
1265 1266 1267 1268
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1269 1270
			if (disk_bytenr == 0)
				goto out_check;
1271 1272 1273 1274
			if (btrfs_file_extent_compression(leaf, fi) ||
			    btrfs_file_extent_encryption(leaf, fi) ||
			    btrfs_file_extent_other_encoding(leaf, fi))
				goto out_check;
1275 1276
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1277
			if (btrfs_extent_readonly(root, disk_bytenr))
1278
				goto out_check;
1279
			if (btrfs_cross_ref_exist(trans, root, ino,
1280 1281
						  found_key.offset -
						  extent_offset, disk_bytenr))
1282
				goto out_check;
1283
			disk_bytenr += extent_offset;
1284 1285 1286 1287 1288 1289 1290 1291 1292
			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;
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
			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;
1314 1315
		}

1316
		btrfs_release_path(path);
1317
		if (cow_start != (u64)-1) {
1318 1319 1320
			ret = __cow_file_range(trans, inode, root, locked_page,
					       cow_start, found_key.offset - 1,
					       page_started, nr_written, 1);
1321 1322 1323 1324
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
1325
			cow_start = (u64)-1;
1326
		}
1327

1328 1329 1330 1331
		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
			struct extent_map *em;
			struct extent_map_tree *em_tree;
			em_tree = &BTRFS_I(inode)->extent_tree;
1332
			em = alloc_extent_map();
1333
			BUG_ON(!em); /* -ENOMEM */
1334
			em->start = cur_offset;
1335
			em->orig_start = found_key.offset - extent_offset;
1336 1337 1338
			em->len = num_bytes;
			em->block_len = num_bytes;
			em->block_start = disk_bytenr;
1339
			em->orig_block_len = disk_num_bytes;
1340 1341
			em->bdev = root->fs_info->fs_devices->latest_bdev;
			set_bit(EXTENT_FLAG_PINNED, &em->flags);
1342
			set_bit(EXTENT_FLAG_FILLING, &em->flags);
1343
			em->generation = -1;
1344
			while (1) {
1345
				write_lock(&em_tree->lock);
1346
				ret = add_extent_mapping(em_tree, em);
1347 1348 1349
				if (!ret)
					list_move(&em->list,
						  &em_tree->modified_extents);
1350
				write_unlock(&em_tree->lock);
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
				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;
		}
1362 1363

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1364
					       num_bytes, num_bytes, type);
1365
		BUG_ON(ret); /* -ENOMEM */
1366

1367 1368 1369 1370
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, cur_offset,
						      num_bytes);
1371 1372 1373 1374
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				goto error;
			}
1375 1376
		}

1377
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1378 1379 1380 1381
				cur_offset, cur_offset + num_bytes - 1,
				locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
				EXTENT_SET_PRIVATE2);
1382 1383 1384
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1385
	}
1386
	btrfs_release_path(path);
1387

1388
	if (cur_offset <= end && cow_start == (u64)-1) {
1389
		cow_start = cur_offset;
1390 1391 1392
		cur_offset = end;
	}

1393
	if (cow_start != (u64)-1) {
1394 1395 1396
		ret = __cow_file_range(trans, inode, root, locked_page,
				       cow_start, end,
				       page_started, nr_written, 1);
1397 1398 1399 1400
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto error;
		}
1401 1402
	}

1403
error:
1404
	err = btrfs_end_transaction(trans, root);
1405 1406 1407
	if (!ret)
		ret = err;

1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	if (ret && cur_offset < end)
		extent_clear_unlock_delalloc(inode,
			     &BTRFS_I(inode)->io_tree,
			     cur_offset, end, locked_page,
			     EXTENT_CLEAR_UNLOCK_PAGE |
			     EXTENT_CLEAR_UNLOCK |
			     EXTENT_CLEAR_DELALLOC |
			     EXTENT_CLEAR_DIRTY |
			     EXTENT_SET_WRITEBACK |
			     EXTENT_END_WRITEBACK);

1419
	btrfs_free_path(path);
1420
	return ret;
1421 1422
}

1423 1424 1425
/*
 * extent_io.c call back to do delayed allocation processing
 */
1426
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1427 1428
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1429 1430
{
	int ret;
1431
	struct btrfs_root *root = BTRFS_I(inode)->root;
1432

1433
	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
1434
		ret = run_delalloc_nocow(inode, locked_page, start, end,
1435
					 page_started, 1, nr_written);
1436
	} else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
1437
		ret = run_delalloc_nocow(inode, locked_page, start, end,
1438
					 page_started, 0, nr_written);
1439 1440 1441
	} else if (!btrfs_test_opt(root, COMPRESS) &&
		   !(BTRFS_I(inode)->force_compress) &&
		   !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
1442 1443
		ret = cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
1444 1445 1446
	} else {
		set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
			&BTRFS_I(inode)->runtime_flags);
1447
		ret = cow_file_range_async(inode, locked_page, start, end,
1448
					   page_started, nr_written);
1449
	}
1450 1451 1452
	return ret;
}

1453 1454
static void btrfs_split_extent_hook(struct inode *inode,
				    struct extent_state *orig, u64 split)
1455
{
1456
	/* not delalloc, ignore it */
1457
	if (!(orig->state & EXTENT_DELALLOC))
1458
		return;
1459

1460 1461 1462
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;
	spin_unlock(&BTRFS_I(inode)->lock);
1463 1464 1465 1466 1467 1468 1469 1470
}

/*
 * 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.
 */
1471 1472 1473
static void btrfs_merge_extent_hook(struct inode *inode,
				    struct extent_state *new,
				    struct extent_state *other)
1474 1475 1476
{
	/* not delalloc, ignore it */
	if (!(other->state & EXTENT_DELALLOC))
1477
		return;
1478

1479 1480 1481
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents--;
	spin_unlock(&BTRFS_I(inode)->lock);
1482 1483
}

1484 1485 1486 1487 1488
/*
 * 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.
 */
1489 1490
static void btrfs_set_bit_hook(struct inode *inode,
			       struct extent_state *state, int *bits)
1491
{
1492

1493 1494
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1495
	 * but in this case, we are only testing for the DELALLOC
1496 1497
	 * bit, which is only set or cleared with irqs on
	 */
1498
	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1499
		struct btrfs_root *root = BTRFS_I(inode)->root;
1500
		u64 len = state->end + 1 - state->start;
1501
		bool do_list = !btrfs_is_free_space_inode(inode);
1502

1503
		if (*bits & EXTENT_FIRST_DELALLOC) {
1504
			*bits &= ~EXTENT_FIRST_DELALLOC;
1505 1506 1507 1508 1509
		} else {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents++;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1510

1511
		spin_lock(&root->fs_info->delalloc_lock);
1512 1513
		BTRFS_I(inode)->delalloc_bytes += len;
		root->fs_info->delalloc_bytes += len;
1514
		if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1515 1516 1517
			list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
				      &root->fs_info->delalloc_inodes);
		}
1518
		spin_unlock(&root->fs_info->delalloc_lock);
1519 1520 1521
	}
}

1522 1523 1524
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1525 1526
static void btrfs_clear_bit_hook(struct inode *inode,
				 struct extent_state *state, int *bits)
1527
{
1528 1529
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1530
	 * but in this case, we are only testing for the DELALLOC
1531 1532
	 * bit, which is only set or cleared with irqs on
	 */
1533
	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1534
		struct btrfs_root *root = BTRFS_I(inode)->root;
1535
		u64 len = state->end + 1 - state->start;
1536
		bool do_list = !btrfs_is_free_space_inode(inode);
1537

1538
		if (*bits & EXTENT_FIRST_DELALLOC) {
1539
			*bits &= ~EXTENT_FIRST_DELALLOC;
1540 1541 1542 1543 1544
		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents--;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1545 1546 1547 1548

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

1549 1550
		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
		    && do_list)
1551
			btrfs_free_reserved_data_space(inode, len);
1552

1553
		spin_lock(&root->fs_info->delalloc_lock);
1554 1555 1556
		root->fs_info->delalloc_bytes -= len;
		BTRFS_I(inode)->delalloc_bytes -= len;

1557
		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1558 1559 1560
		    !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
			list_del_init(&BTRFS_I(inode)->delalloc_inodes);
		}
1561
		spin_unlock(&root->fs_info->delalloc_lock);
1562 1563 1564
	}
}

1565 1566 1567 1568
/*
 * 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
 */
1569
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1570 1571
			 size_t size, struct bio *bio,
			 unsigned long bio_flags)
1572 1573
{
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1574
	u64 logical = (u64)bio->bi_sector << 9;
1575 1576 1577 1578
	u64 length = 0;
	u64 map_length;
	int ret;

1579 1580 1581
	if (bio_flags & EXTENT_BIO_COMPRESSED)
		return 0;

1582
	length = bio->bi_size;
1583
	map_length = length;
1584
	ret = btrfs_map_block(root->fs_info, READ, logical,
1585
			      &map_length, NULL, 0);
1586
	/* Will always return 0 with map_multi == NULL */
1587
	BUG_ON(ret < 0);
1588
	if (map_length < length + size)
1589
		return 1;
1590
	return 0;
1591 1592
}

1593 1594 1595 1596 1597 1598 1599 1600
/*
 * 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
 */
1601 1602
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
1603 1604
				    unsigned long bio_flags,
				    u64 bio_offset)
1605 1606 1607
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1608

1609
	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1610
	BUG_ON(ret); /* -ENOMEM */
1611 1612
	return 0;
}
1613

1614 1615 1616 1617 1618 1619 1620 1621
/*
 * 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
 */
1622
static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1623 1624
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1625 1626
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1627 1628 1629 1630 1631 1632
	int ret;

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

1635
/*
1636 1637
 * 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
1638
 */
1639
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1640 1641
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1642 1643 1644
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1645
	int skip_sum;
1646
	int metadata = 0;
1647
	int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1648

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

1651
	if (btrfs_is_free_space_inode(inode))
1652 1653
		metadata = 2;

1654
	if (!(rw & REQ_WRITE)) {
1655 1656
		ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
		if (ret)
1657
			goto out;
1658

1659
		if (bio_flags & EXTENT_BIO_COMPRESSED) {
1660 1661 1662 1663
			ret = btrfs_submit_compressed_read(inode, bio,
							   mirror_num,
							   bio_flags);
			goto out;
1664 1665 1666
		} else if (!skip_sum) {
			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
			if (ret)
1667
				goto out;
1668
		}
1669
		goto mapit;
1670
	} else if (async && !skip_sum) {
1671 1672 1673
		/* csum items have already been cloned */
		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
			goto mapit;
1674
		/* we're doing a write, do the async checksumming */
1675
		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1676
				   inode, rw, bio, mirror_num,
1677 1678
				   bio_flags, bio_offset,
				   __btrfs_submit_bio_start,
1679
				   __btrfs_submit_bio_done);
1680
		goto out;
1681 1682 1683 1684
	} else if (!skip_sum) {
		ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
		if (ret)
			goto out;
1685 1686
	}

1687
mapit:
1688 1689 1690 1691 1692 1693
	ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);

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

1696 1697 1698 1699
/*
 * 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.
 */
1700
static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1701 1702 1703 1704 1705
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

1706
	list_for_each_entry(sum, list, list) {
1707 1708
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
1709 1710 1711 1712
	}
	return 0;
}

1713 1714
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
			      struct extent_state **cached_state)
1715
{
1716
	WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1717
	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1718
				   cached_state, GFP_NOFS);
1719 1720
}

1721
/* see btrfs_writepage_start_hook for details on why this is required */
1722 1723 1724 1725 1726
struct btrfs_writepage_fixup {
	struct page *page;
	struct btrfs_work work;
};

1727
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1728 1729 1730
{
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_ordered_extent *ordered;
1731
	struct extent_state *cached_state = NULL;
1732 1733 1734 1735
	struct page *page;
	struct inode *inode;
	u64 page_start;
	u64 page_end;
1736
	int ret;
1737 1738 1739

	fixup = container_of(work, struct btrfs_writepage_fixup, work);
	page = fixup->page;
C
Chris Mason 已提交
1740
again:
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
	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;

1751
	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1752
			 &cached_state);
C
Chris Mason 已提交
1753 1754

	/* already ordered? We're done */
1755
	if (PagePrivate2(page))
1756
		goto out;
C
Chris Mason 已提交
1757 1758 1759

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
1760 1761
		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
				     page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
1762 1763
		unlock_page(page);
		btrfs_start_ordered_extent(inode, ordered, 1);
1764
		btrfs_put_ordered_extent(ordered);
C
Chris Mason 已提交
1765 1766
		goto again;
	}
1767

1768 1769 1770 1771 1772 1773 1774 1775
	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;
	 }

1776
	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1777
	ClearPageChecked(page);
1778
	set_page_dirty(page);
1779
out:
1780 1781
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
			     &cached_state, GFP_NOFS);
1782 1783 1784
out_page:
	unlock_page(page);
	page_cache_release(page);
1785
	kfree(fixup);
1786 1787 1788 1789 1790 1791 1792 1793
}

/*
 * 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.
 *
1794
 * In our case any range that doesn't have the ORDERED bit set
1795 1796 1797 1798
 * 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.
 */
1799
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1800 1801 1802 1803 1804
{
	struct inode *inode = page->mapping->host;
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_root *root = BTRFS_I(inode)->root;

1805 1806
	/* this page is properly in the ordered list */
	if (TestClearPagePrivate2(page))
1807 1808 1809 1810 1811 1812 1813 1814
		return 0;

	if (PageChecked(page))
		return -EAGAIN;

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

1816 1817 1818 1819 1820
	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);
1821
	return -EBUSY;
1822 1823
}

1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
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();
1839 1840
	if (!path)
		return -ENOMEM;
1841

1842
	path->leave_spinning = 1;
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852

	/*
	 * 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 已提交
1853
	ret = btrfs_drop_extents(trans, root, inode, file_pos,
1854
				 file_pos + num_bytes, 0);
1855 1856
	if (ret)
		goto out;
1857

1858
	ins.objectid = btrfs_ino(inode);
1859 1860 1861
	ins.offset = file_pos;
	ins.type = BTRFS_EXTENT_DATA_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1862 1863
	if (ret)
		goto out;
1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
	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);
1877

1878
	btrfs_mark_buffer_dirty(leaf);
1879
	btrfs_release_path(path);
1880 1881 1882 1883 1884 1885

	inode_add_bytes(inode, num_bytes);

	ins.objectid = disk_bytenr;
	ins.offset = disk_num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
1886 1887
	ret = btrfs_alloc_reserved_file_extent(trans, root,
					root->root_key.objectid,
1888
					btrfs_ino(inode), file_pos, &ins);
1889
out:
1890
	btrfs_free_path(path);
1891

1892
	return ret;
1893 1894
}

1895 1896 1897 1898 1899 1900
/*
 * 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.
 */
1901 1902 1903 1904
/* 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.
 */
1905
static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
1906
{
1907
	struct inode *inode = ordered_extent->inode;
1908
	struct btrfs_root *root = BTRFS_I(inode)->root;
1909
	struct btrfs_trans_handle *trans = NULL;
1910
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1911
	struct extent_state *cached_state = NULL;
1912
	int compress_type = 0;
1913
	int ret;
1914
	bool nolock;
1915

1916
	nolock = btrfs_is_free_space_inode(inode);
1917

1918 1919 1920 1921 1922
	if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
		ret = -EIO;
		goto out;
	}

1923
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
1924
		BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
1925 1926
		ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
		if (!ret) {
1927
			if (nolock)
1928
				trans = btrfs_join_transaction_nolock(root);
1929
			else
1930
				trans = btrfs_join_transaction(root);
1931 1932 1933 1934 1935
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				trans = NULL;
				goto out;
			}
1936
			trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1937
			ret = btrfs_update_inode_fallback(trans, root, inode);
1938 1939
			if (ret) /* -ENOMEM or corruption */
				btrfs_abort_transaction(trans, root, ret);
1940 1941 1942
		}
		goto out;
	}
1943

1944 1945
	lock_extent_bits(io_tree, ordered_extent->file_offset,
			 ordered_extent->file_offset + ordered_extent->len - 1,
1946
			 0, &cached_state);
1947

1948
	if (nolock)
1949
		trans = btrfs_join_transaction_nolock(root);
1950
	else
1951
		trans = btrfs_join_transaction(root);
1952 1953 1954 1955 1956
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		trans = NULL;
		goto out_unlock;
	}
1957
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1958

1959
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
1960
		compress_type = ordered_extent->compress_type;
1961
	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1962
		BUG_ON(compress_type);
1963
		ret = btrfs_mark_extent_written(trans, inode,
1964 1965 1966 1967
						ordered_extent->file_offset,
						ordered_extent->file_offset +
						ordered_extent->len);
	} else {
1968
		BUG_ON(root == root->fs_info->tree_root);
1969 1970 1971 1972 1973 1974
		ret = insert_reserved_file_extent(trans, inode,
						ordered_extent->file_offset,
						ordered_extent->start,
						ordered_extent->disk_len,
						ordered_extent->len,
						ordered_extent->len,
1975
						compress_type, 0, 0,
1976 1977
						BTRFS_FILE_EXTENT_REG);
	}
J
Josef Bacik 已提交
1978 1979 1980
	unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
			   ordered_extent->file_offset, ordered_extent->len,
			   trans->transid);
1981 1982
	if (ret < 0) {
		btrfs_abort_transaction(trans, root, ret);
1983
		goto out_unlock;
1984
	}
1985

1986 1987 1988
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

1989
	ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1990
	if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1991
		ret = btrfs_update_inode_fallback(trans, root, inode);
1992 1993
		if (ret) { /* -ENOMEM or corruption */
			btrfs_abort_transaction(trans, root, ret);
1994
			goto out_unlock;
1995
		}
1996 1997
	} else {
		btrfs_set_inode_last_trans(trans, inode);
1998 1999
	}
	ret = 0;
2000 2001 2002 2003
out_unlock:
	unlock_extent_cached(io_tree, ordered_extent->file_offset,
			     ordered_extent->file_offset +
			     ordered_extent->len - 1, &cached_state, GFP_NOFS);
2004
out:
2005
	if (root != root->fs_info->tree_root)
2006
		btrfs_delalloc_release_metadata(inode, ordered_extent->len);
2007 2008
	if (trans)
		btrfs_end_transaction(trans, root);
2009

2010 2011 2012 2013 2014 2015
	if (ret)
		clear_extent_uptodate(io_tree, ordered_extent->file_offset,
				      ordered_extent->file_offset +
				      ordered_extent->len - 1, NULL, GFP_NOFS);

	/*
2016 2017
	 * This needs to be done to make sure anybody waiting knows we are done
	 * updating everything for this ordered extent.
2018 2019 2020
	 */
	btrfs_remove_ordered_extent(inode, ordered_extent);

2021 2022 2023 2024 2025
	/* once for us */
	btrfs_put_ordered_extent(ordered_extent);
	/* once for the tree */
	btrfs_put_ordered_extent(ordered_extent);

2026 2027 2028 2029 2030 2031 2032 2033
	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);
2034 2035
}

2036
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2037 2038
				struct extent_state *state, int uptodate)
{
2039 2040 2041 2042 2043
	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;

2044 2045
	trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);

2046
	ClearPagePrivate2(page);
2047 2048 2049 2050 2051 2052 2053
	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;

2054
	if (btrfs_is_free_space_inode(inode))
2055 2056 2057 2058 2059 2060
		workers = &root->fs_info->endio_freespace_worker;
	else
		workers = &root->fs_info->endio_write_workers;
	btrfs_queue_worker(workers, &ordered_extent->work);

	return 0;
2061 2062
}

2063 2064
/*
 * when reads are done, we need to check csums to verify the data is correct
2065 2066
 * 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.
2067
 */
2068
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
2069
			       struct extent_state *state, int mirror)
2070
{
2071
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
2072
	struct inode *inode = page->mapping->host;
2073
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2074
	char *kaddr;
2075
	u64 private = ~(u32)0;
2076
	int ret;
2077 2078
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
2079

2080 2081 2082 2083
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
2084 2085

	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
2086
		goto good;
2087 2088

	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
2089
	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
2090 2091
		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
				  GFP_NOFS);
2092
		return 0;
2093
	}
2094

Y
Yan 已提交
2095
	if (state && state->start == start) {
2096 2097 2098 2099 2100
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
2101
	kaddr = kmap_atomic(page);
2102
	if (ret)
2103
		goto zeroit;
2104

2105 2106
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
2107
	if (csum != private)
2108
		goto zeroit;
2109

2110
	kunmap_atomic(kaddr);
2111
good:
2112 2113 2114
	return 0;

zeroit:
2115
	printk_ratelimited(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
2116 2117
		       "private %llu\n",
		       (unsigned long long)btrfs_ino(page->mapping->host),
2118 2119
		       (unsigned long long)start, csum,
		       (unsigned long long)private);
2120 2121
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
2122
	kunmap_atomic(kaddr);
2123 2124
	if (private == 0)
		return 0;
2125
	return -EIO;
2126
}
2127

Y
Yan, Zheng 已提交
2128 2129 2130 2131 2132
struct delayed_iput {
	struct list_head list;
	struct inode *inode;
};

2133 2134
/* JDM: If this is fs-wide, why can't we add a pointer to
 * btrfs_inode instead and avoid the allocation? */
Y
Yan, Zheng 已提交
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
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);
	}
}

2176 2177 2178 2179 2180 2181
enum btrfs_orphan_cleanup_state {
	ORPHAN_CLEANUP_STARTED	= 1,
	ORPHAN_CLEANUP_DONE	= 2,
};

/*
2182
 * This is called in transaction commit time. If there are no orphan
2183 2184 2185 2186 2187 2188
 * 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)
{
2189
	struct btrfs_block_rsv *block_rsv;
2190 2191
	int ret;

2192
	if (atomic_read(&root->orphan_inodes) ||
2193 2194 2195
	    root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
		return;

2196
	spin_lock(&root->orphan_lock);
2197
	if (atomic_read(&root->orphan_inodes)) {
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
		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);

2211 2212 2213 2214 2215 2216 2217 2218
	if (root->orphan_item_inserted &&
	    btrfs_root_refs(&root->root_item) > 0) {
		ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
					    root->root_key.objectid);
		BUG_ON(ret);
		root->orphan_item_inserted = 0;
	}

2219 2220 2221
	if (block_rsv) {
		WARN_ON(block_rsv->size > 0);
		btrfs_free_block_rsv(root, block_rsv);
2222 2223 2224
	}
}

2225 2226 2227
/*
 * This creates an orphan entry for the given inode in case something goes
 * wrong in the middle of an unlink/truncate.
2228 2229 2230
 *
 * NOTE: caller of this function should reserve 5 units of metadata for
 *	 this function.
2231 2232 2233 2234
 */
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
2235 2236 2237 2238
	struct btrfs_block_rsv *block_rsv = NULL;
	int reserve = 0;
	int insert = 0;
	int ret;
2239

2240
	if (!root->orphan_block_rsv) {
2241
		block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
2242 2243
		if (!block_rsv)
			return -ENOMEM;
2244
	}
2245

2246 2247 2248 2249 2250 2251
	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;
2252 2253
	}

2254 2255
	if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			      &BTRFS_I(inode)->runtime_flags)) {
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
#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;
2268
		atomic_inc(&root->orphan_inodes);
2269 2270
	}

2271 2272
	if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			      &BTRFS_I(inode)->runtime_flags))
2273 2274
		reserve = 1;
	spin_unlock(&root->orphan_lock);
2275

2276 2277 2278
	/* grab metadata reservation from transaction handle */
	if (reserve) {
		ret = btrfs_orphan_reserve_metadata(trans, inode);
2279
		BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */
2280
	}
2281

2282 2283
	/* insert an orphan item to track this unlinked/truncated file */
	if (insert >= 1) {
2284
		ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
2285
		if (ret && ret != -EEXIST) {
2286 2287
			clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
				  &BTRFS_I(inode)->runtime_flags);
2288 2289 2290 2291
			btrfs_abort_transaction(trans, root, ret);
			return ret;
		}
		ret = 0;
2292 2293 2294 2295 2296 2297
	}

	/* 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);
2298 2299 2300 2301
		if (ret && ret != -EEXIST) {
			btrfs_abort_transaction(trans, root, ret);
			return ret;
		}
2302 2303
	}
	return 0;
2304 2305 2306 2307 2308 2309 2310 2311 2312
}

/*
 * We have done the truncate/delete so we can go ahead and remove the orphan
 * item for this particular inode.
 */
int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
2313 2314
	int delete_item = 0;
	int release_rsv = 0;
2315 2316
	int ret = 0;

2317
	spin_lock(&root->orphan_lock);
2318 2319
	if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			       &BTRFS_I(inode)->runtime_flags))
2320
		delete_item = 1;
2321

2322 2323
	if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
			       &BTRFS_I(inode)->runtime_flags))
2324 2325
		release_rsv = 1;
	spin_unlock(&root->orphan_lock);
2326

2327
	if (trans && delete_item) {
2328
		ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
2329
		BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
2330
	}
2331

2332
	if (release_rsv) {
2333
		btrfs_orphan_release_metadata(inode);
2334 2335
		atomic_dec(&root->orphan_inodes);
	}
2336

2337
	return 0;
2338 2339 2340 2341 2342 2343
}

/*
 * this cleans up any orphans that may be left on the list from the last use
 * of this root.
 */
2344
int btrfs_orphan_cleanup(struct btrfs_root *root)
2345 2346 2347 2348 2349 2350
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key, found_key;
	struct btrfs_trans_handle *trans;
	struct inode *inode;
2351
	u64 last_objectid = 0;
2352 2353
	int ret = 0, nr_unlink = 0, nr_truncate = 0;

2354
	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
2355
		return 0;
2356 2357

	path = btrfs_alloc_path();
2358 2359 2360 2361
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}
2362 2363 2364 2365 2366 2367 2368 2369
	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);
2370 2371
		if (ret < 0)
			goto out;
2372 2373 2374

		/*
		 * if ret == 0 means we found what we were searching for, which
L
Lucas De Marchi 已提交
2375
		 * is weird, but possible, so only screw with path if we didn't
2376 2377 2378
		 * find the key and see if we have stuff that matches
		 */
		if (ret > 0) {
2379
			ret = 0;
2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395
			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 */
2396
		btrfs_release_path(path);
2397 2398 2399 2400 2401 2402

		/*
		 * 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.
		 */
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412

		if (found_key.offset == last_objectid) {
			printk(KERN_ERR "btrfs: Error removing orphan entry, "
			       "stopping orphan cleanup\n");
			ret = -EINVAL;
			goto out;
		}

		last_objectid = found_key.offset;

2413 2414 2415
		found_key.objectid = found_key.offset;
		found_key.type = BTRFS_INODE_ITEM_KEY;
		found_key.offset = 0;
2416
		inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
2417 2418
		ret = PTR_RET(inode);
		if (ret && ret != -ESTALE)
2419
			goto out;
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
		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;
			}
		}
2453
		/*
2454 2455
		 * Inode is already gone but the orphan item is still there,
		 * kill the orphan item.
2456
		 */
2457 2458
		if (ret == -ESTALE) {
			trans = btrfs_start_transaction(root, 1);
2459 2460 2461 2462
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				goto out;
			}
2463 2464
			printk(KERN_ERR "auto deleting %Lu\n",
			       found_key.objectid);
2465 2466
			ret = btrfs_del_orphan_item(trans, root,
						    found_key.objectid);
2467
			BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
2468
			btrfs_end_transaction(trans, root);
2469 2470 2471
			continue;
		}

2472 2473 2474 2475
		/*
		 * add this inode to the orphan list so btrfs_orphan_del does
		 * the proper thing when we hit it
		 */
2476 2477
		set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
			&BTRFS_I(inode)->runtime_flags);
2478

2479 2480
		/* if we have links, this was a truncate, lets do that */
		if (inode->i_nlink) {
2481 2482 2483 2484 2485
			if (!S_ISREG(inode->i_mode)) {
				WARN_ON(1);
				iput(inode);
				continue;
			}
2486
			nr_truncate++;
2487
			ret = btrfs_truncate(inode);
2488 2489 2490 2491 2492 2493
		} else {
			nr_unlink++;
		}

		/* this will do delete_inode and everything for us */
		iput(inode);
2494 2495
		if (ret)
			goto out;
2496
	}
2497 2498 2499
	/* release the path since we're done with it */
	btrfs_release_path(path);

2500 2501 2502 2503 2504 2505 2506
	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) {
2507
		trans = btrfs_join_transaction(root);
2508 2509
		if (!IS_ERR(trans))
			btrfs_end_transaction(trans, root);
2510
	}
2511 2512 2513 2514 2515

	if (nr_unlink)
		printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
	if (nr_truncate)
		printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
2516 2517 2518 2519 2520 2521

out:
	if (ret)
		printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
	btrfs_free_path(path);
	return ret;
2522 2523
}

2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
/*
 * 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;
	int scanned = 0;

	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 */
		if (found_key.type == BTRFS_XATTR_ITEM_KEY)
			return 1;

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

2575 2576 2577
/*
 * read an inode from the btree into the in-memory inode
 */
2578
static void btrfs_read_locked_inode(struct inode *inode)
C
Chris Mason 已提交
2579 2580
{
	struct btrfs_path *path;
2581
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2582
	struct btrfs_inode_item *inode_item;
2583
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
2584 2585
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
2586
	int maybe_acls;
J
Josef Bacik 已提交
2587
	u32 rdev;
C
Chris Mason 已提交
2588
	int ret;
2589 2590 2591 2592 2593
	bool filled = false;

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

	path = btrfs_alloc_path();
2596 2597 2598
	if (!path)
		goto make_bad;

2599
	path->leave_spinning = 1;
C
Chris Mason 已提交
2600
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
2601

C
Chris Mason 已提交
2602
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2603
	if (ret)
C
Chris Mason 已提交
2604 2605
		goto make_bad;

2606
	leaf = path->nodes[0];
2607 2608 2609 2610

	if (filled)
		goto cache_acl;

2611 2612 2613
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_inode_item);
	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
2614
	set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
2615 2616
	i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
	i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
2617
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630

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

2631
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2632
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
J
Josef Bacik 已提交
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644
	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);

2645
	inode->i_version = btrfs_inode_sequence(leaf, inode_item);
2646
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
2647
	inode->i_rdev = 0;
2648 2649
	rdev = btrfs_inode_rdev(leaf, inode_item);

2650
	BTRFS_I(inode)->index_cnt = (u64)-1;
2651
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2652
cache_acl:
2653 2654 2655 2656
	/*
	 * try to precache a NULL acl entry for files that don't have
	 * any xattrs or acls
	 */
2657 2658
	maybe_acls = acls_after_inode_item(leaf, path->slots[0],
					   btrfs_ino(inode));
2659 2660
	if (!maybe_acls)
		cache_no_acl(inode);
2661

C
Chris Mason 已提交
2662 2663 2664 2665 2666
	btrfs_free_path(path);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
2667
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2668
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681
		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;
2682
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
2683
		break;
J
Josef Bacik 已提交
2684
	default:
J
Jim Owens 已提交
2685
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
2686 2687
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
2688
	}
2689 2690

	btrfs_update_iflags(inode);
C
Chris Mason 已提交
2691 2692 2693 2694 2695 2696 2697
	return;

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

2698 2699 2700
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
2701 2702
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
2703
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
2704 2705
			    struct inode *inode)
{
2706 2707
	btrfs_set_inode_uid(leaf, item, i_uid_read(inode));
	btrfs_set_inode_gid(leaf, item, i_gid_read(inode));
2708
	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726
	btrfs_set_inode_mode(leaf, item, inode->i_mode);
	btrfs_set_inode_nlink(leaf, item, inode->i_nlink);

	btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
			       inode->i_atime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
				inode->i_atime.tv_nsec);

	btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
			       inode->i_mtime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
				inode->i_mtime.tv_nsec);

	btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
			       inode->i_ctime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
				inode->i_ctime.tv_nsec);

2727
	btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2728
	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2729
	btrfs_set_inode_sequence(leaf, item, inode->i_version);
2730
	btrfs_set_inode_transid(leaf, item, trans->transid);
2731
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
Y
Yan 已提交
2732
	btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2733
	btrfs_set_inode_block_group(leaf, item, 0);
C
Chris Mason 已提交
2734 2735
}

2736 2737 2738
/*
 * copy everything in the in-memory inode into the btree.
 */
2739
static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
2740
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
2741 2742 2743
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
2744
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2745 2746 2747
	int ret;

	path = btrfs_alloc_path();
2748 2749 2750
	if (!path)
		return -ENOMEM;

2751
	path->leave_spinning = 1;
2752 2753
	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
				 1);
C
Chris Mason 已提交
2754 2755 2756 2757 2758 2759
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

2760
	btrfs_unlock_up_safe(path, 1);
2761 2762
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
2763
				    struct btrfs_inode_item);
C
Chris Mason 已提交
2764

2765
	fill_inode_item(trans, leaf, inode_item, inode);
2766
	btrfs_mark_buffer_dirty(leaf);
2767
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
2768 2769 2770 2771 2772 2773
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}

2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788
/*
 * 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
	 */
2789
	if (!btrfs_is_free_space_inode(inode)
2790
	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
2791 2792
		btrfs_update_root_times(trans, root);

2793 2794 2795 2796 2797 2798 2799 2800 2801
		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);
}

2802 2803 2804
noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root,
					 struct inode *inode)
2805 2806 2807 2808 2809 2810 2811 2812 2813
{
	int ret;

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

2814 2815 2816 2817 2818
/*
 * 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
 */
2819 2820 2821 2822
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 已提交
2823 2824 2825
{
	struct btrfs_path *path;
	int ret = 0;
2826
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2827
	struct btrfs_dir_item *di;
2828
	struct btrfs_key key;
2829
	u64 index;
2830 2831
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
C
Chris Mason 已提交
2832 2833

	path = btrfs_alloc_path();
2834 2835
	if (!path) {
		ret = -ENOMEM;
2836
		goto out;
2837 2838
	}

2839
	path->leave_spinning = 1;
2840
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
C
Chris Mason 已提交
2841 2842 2843 2844 2845 2846 2847 2848 2849
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
2850 2851
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
2852
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2853 2854
	if (ret)
		goto err;
2855
	btrfs_release_path(path);
C
Chris Mason 已提交
2856

2857 2858
	ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
				  dir_ino, &index);
2859
	if (ret) {
2860
		printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2861 2862
		       "inode %llu parent %llu\n", name_len, name,
		       (unsigned long long)ino, (unsigned long long)dir_ino);
2863
		btrfs_abort_transaction(trans, root, ret);
2864 2865 2866
		goto err;
	}

2867
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
2868 2869
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
C
Chris Mason 已提交
2870
		goto err;
2871
	}
C
Chris Mason 已提交
2872

2873
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
2874
					 inode, dir_ino);
2875 2876 2877 2878
	if (ret != 0 && ret != -ENOENT) {
		btrfs_abort_transaction(trans, root, ret);
		goto err;
	}
2879 2880 2881

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
2882 2883
	if (ret == -ENOENT)
		ret = 0;
C
Chris Mason 已提交
2884 2885
err:
	btrfs_free_path(path);
2886 2887 2888 2889
	if (ret)
		goto out;

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
2890 2891
	inode_inc_iversion(inode);
	inode_inc_iversion(dir);
2892
	inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
2893
	ret = btrfs_update_inode(trans, root, dir);
2894
out:
C
Chris Mason 已提交
2895 2896 2897
	return ret;
}

2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912
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;
}
		

2913 2914 2915
/* helper to check if there is any shared block in the path */
static int check_path_shared(struct btrfs_root *root,
			     struct btrfs_path *path)
C
Chris Mason 已提交
2916
{
2917 2918
	struct extent_buffer *eb;
	int level;
2919
	u64 refs = 1;
2920

2921
	for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2922 2923
		int ret;

2924 2925 2926 2927 2928 2929 2930 2931 2932
		if (!path->nodes[level])
			break;
		eb = path->nodes[level];
		if (!btrfs_block_can_be_shared(root, eb))
			continue;
		ret = btrfs_lookup_extent_info(NULL, root, eb->start, eb->len,
					       &refs, NULL);
		if (refs > 1)
			return 1;
2933
	}
2934
	return 0;
C
Chris Mason 已提交
2935 2936
}

2937 2938 2939 2940 2941 2942 2943 2944 2945
/*
 * helper to start transaction for unlink and rmdir.
 *
 * unlink and rmdir are special in btrfs, they do not always free space.
 * so in enospc case, we should make sure they will free space before
 * allowing them to use the global metadata reservation.
 */
static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
						       struct dentry *dentry)
2946
{
C
Chris Mason 已提交
2947
	struct btrfs_trans_handle *trans;
2948
	struct btrfs_root *root = BTRFS_I(dir)->root;
2949 2950
	struct btrfs_path *path;
	struct btrfs_dir_item *di;
2951
	struct inode *inode = dentry->d_inode;
2952
	u64 index;
2953 2954
	int check_link = 1;
	int err = -ENOSPC;
2955
	int ret;
2956 2957
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
2958

2959 2960 2961 2962 2963 2964 2965 2966 2967 2968
	/*
	 * 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 ref in the tree log
	 * 2 for the dir entries in the log
	 * 1 for the inode
	 */
	trans = btrfs_start_transaction(root, 8);
2969 2970
	if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
		return trans;
2971

2972
	if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
2973
		return ERR_PTR(-ENOSPC);
2974

2975 2976 2977
	/* check if there is someone else holds reference */
	if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
		return ERR_PTR(-ENOSPC);
2978

2979 2980
	if (atomic_read(&inode->i_count) > 2)
		return ERR_PTR(-ENOSPC);
2981

2982 2983 2984 2985 2986 2987 2988
	if (xchg(&root->fs_info->enospc_unlink, 1))
		return ERR_PTR(-ENOSPC);

	path = btrfs_alloc_path();
	if (!path) {
		root->fs_info->enospc_unlink = 0;
		return ERR_PTR(-ENOMEM);
2989 2990
	}

2991 2992
	/* 1 for the orphan item */
	trans = btrfs_start_transaction(root, 1);
2993
	if (IS_ERR(trans)) {
2994 2995 2996 2997
		btrfs_free_path(path);
		root->fs_info->enospc_unlink = 0;
		return trans;
	}
2998

2999 3000
	path->skip_locking = 1;
	path->search_commit_root = 1;
3001

3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012
	ret = btrfs_lookup_inode(trans, root, path,
				&BTRFS_I(dir)->location, 0);
	if (ret < 0) {
		err = ret;
		goto out;
	}
	if (ret == 0) {
		if (check_path_shared(root, path))
			goto out;
	} else {
		check_link = 0;
3013
	}
3014
	btrfs_release_path(path);
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027

	ret = btrfs_lookup_inode(trans, root, path,
				&BTRFS_I(inode)->location, 0);
	if (ret < 0) {
		err = ret;
		goto out;
	}
	if (ret == 0) {
		if (check_path_shared(root, path))
			goto out;
	} else {
		check_link = 0;
	}
3028
	btrfs_release_path(path);
3029 3030 3031

	if (ret == 0 && S_ISREG(inode->i_mode)) {
		ret = btrfs_lookup_file_extent(trans, root, path,
3032
					       ino, (u64)-1, 0);
3033 3034 3035 3036
		if (ret < 0) {
			err = ret;
			goto out;
		}
3037
		BUG_ON(ret == 0); /* Corruption */
3038 3039
		if (check_path_shared(root, path))
			goto out;
3040
		btrfs_release_path(path);
3041 3042 3043 3044 3045 3046 3047
	}

	if (!check_link) {
		err = 0;
		goto out;
	}

3048
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
				dentry->d_name.name, dentry->d_name.len, 0);
	if (IS_ERR(di)) {
		err = PTR_ERR(di);
		goto out;
	}
	if (di) {
		if (check_path_shared(root, path))
			goto out;
	} else {
		err = 0;
		goto out;
	}
3061
	btrfs_release_path(path);
3062

M
Mark Fasheh 已提交
3063 3064 3065 3066 3067
	ret = btrfs_get_inode_ref_index(trans, root, path, dentry->d_name.name,
					dentry->d_name.len, ino, dir_ino, 0,
					&index);
	if (ret) {
		err = ret;
3068 3069
		goto out;
	}
M
Mark Fasheh 已提交
3070

3071 3072
	if (check_path_shared(root, path))
		goto out;
M
Mark Fasheh 已提交
3073

3074
	btrfs_release_path(path);
3075

3076 3077 3078 3079 3080 3081 3082 3083
	/*
	 * This is a commit root search, if we can lookup inode item and other
	 * relative items in the commit root, it means the transaction of
	 * dir/file creation has been committed, and the dir index item that we
	 * delay to insert has also been inserted into the commit root. So
	 * we needn't worry about the delayed insertion of the dir index item
	 * here.
	 */
3084
	di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
				dentry->d_name.name, dentry->d_name.len, 0);
	if (IS_ERR(di)) {
		err = PTR_ERR(di);
		goto out;
	}
	BUG_ON(ret == -ENOENT);
	if (check_path_shared(root, path))
		goto out;

	err = 0;
out:
	btrfs_free_path(path);
3097 3098 3099 3100
	/* Migrate the orphan reservation over */
	if (!err)
		err = btrfs_block_rsv_migrate(trans->block_rsv,
				&root->fs_info->global_block_rsv,
3101
				trans->bytes_reserved);
3102

3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
	if (err) {
		btrfs_end_transaction(trans, root);
		root->fs_info->enospc_unlink = 0;
		return ERR_PTR(err);
	}

	trans->block_rsv = &root->fs_info->global_block_rsv;
	return trans;
}

static void __unlink_end_trans(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
{
3116
	if (trans->block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL) {
3117 3118 3119
		btrfs_block_rsv_release(root, trans->block_rsv,
					trans->bytes_reserved);
		trans->block_rsv = &root->fs_info->trans_block_rsv;
3120 3121 3122
		BUG_ON(!root->fs_info->enospc_unlink);
		root->fs_info->enospc_unlink = 0;
	}
3123
	btrfs_end_transaction(trans, root);
3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135
}

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;

	trans = __unlink_start_trans(dir, dentry);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3136

3137 3138
	btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);

3139 3140
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
3141 3142
	if (ret)
		goto out;
3143

3144
	if (inode->i_nlink == 0) {
3145
		ret = btrfs_orphan_add(trans, inode);
3146 3147
		if (ret)
			goto out;
3148
	}
3149

3150
out:
3151
	__unlink_end_trans(trans, root);
3152
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
3153 3154 3155
	return ret;
}

3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166
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;
3167
	u64 dir_ino = btrfs_ino(dir);
3168 3169 3170 3171 3172

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

3173
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3174
				   name, name_len, -1);
3175 3176 3177 3178 3179 3180 3181
	if (IS_ERR_OR_NULL(di)) {
		if (!di)
			ret = -ENOENT;
		else
			ret = PTR_ERR(di);
		goto out;
	}
3182 3183 3184 3185 3186

	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);
3187 3188 3189 3190
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3191
	btrfs_release_path(path);
3192 3193 3194

	ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
				 objectid, root->root_key.objectid,
3195
				 dir_ino, &index, name, name_len);
3196
	if (ret < 0) {
3197 3198 3199 3200
		if (ret != -ENOENT) {
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
3201
		di = btrfs_search_dir_index_item(root, path, dir_ino,
3202
						 name, name_len);
3203 3204 3205 3206 3207 3208 3209 3210
		if (IS_ERR_OR_NULL(di)) {
			if (!di)
				ret = -ENOENT;
			else
				ret = PTR_ERR(di);
			btrfs_abort_transaction(trans, root, ret);
			goto out;
		}
3211 3212 3213

		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3214
		btrfs_release_path(path);
3215 3216
		index = key.offset;
	}
3217
	btrfs_release_path(path);
3218

3219
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3220 3221 3222 3223
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
3224 3225

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3226
	inode_inc_iversion(dir);
3227
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3228
	ret = btrfs_update_inode_fallback(trans, root, dir);
3229 3230 3231
	if (ret)
		btrfs_abort_transaction(trans, root, ret);
out:
3232
	btrfs_free_path(path);
3233
	return ret;
3234 3235
}

C
Chris Mason 已提交
3236 3237 3238
static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
3239
	int err = 0;
C
Chris Mason 已提交
3240 3241 3242
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;

3243
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
Y
Yan 已提交
3244
		return -ENOTEMPTY;
3245 3246
	if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
		return -EPERM;
Y
Yan 已提交
3247

3248 3249
	trans = __unlink_start_trans(dir, dentry);
	if (IS_ERR(trans))
3250 3251
		return PTR_ERR(trans);

3252
	if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
3253 3254 3255 3256 3257 3258 3259
		err = btrfs_unlink_subvol(trans, root, dir,
					  BTRFS_I(inode)->location.objectid,
					  dentry->d_name.name,
					  dentry->d_name.len);
		goto out;
	}

3260 3261
	err = btrfs_orphan_add(trans, inode);
	if (err)
3262
		goto out;
3263

C
Chris Mason 已提交
3264
	/* now the directory is empty */
3265 3266
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
3267
	if (!err)
3268
		btrfs_i_size_write(inode, 0);
3269
out:
3270
	__unlink_end_trans(trans, root);
3271
	btrfs_btree_balance_dirty(root);
3272

C
Chris Mason 已提交
3273 3274 3275 3276 3277 3278
	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
3279
 * any higher than new_size
C
Chris Mason 已提交
3280 3281 3282
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
3283 3284 3285
 *
 * 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 已提交
3286
 */
3287 3288 3289 3290
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 已提交
3291 3292
{
	struct btrfs_path *path;
3293
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3294
	struct btrfs_file_extent_item *fi;
3295 3296
	struct btrfs_key key;
	struct btrfs_key found_key;
C
Chris Mason 已提交
3297
	u64 extent_start = 0;
3298
	u64 extent_num_bytes = 0;
3299
	u64 extent_offset = 0;
C
Chris Mason 已提交
3300
	u64 item_end = 0;
3301 3302
	u64 mask = root->sectorsize - 1;
	u32 found_type = (u8)-1;
C
Chris Mason 已提交
3303 3304
	int found_extent;
	int del_item;
3305 3306
	int pending_del_nr = 0;
	int pending_del_slot = 0;
3307
	int extent_type = -1;
3308 3309
	int ret;
	int err = 0;
3310
	u64 ino = btrfs_ino(inode);
3311 3312

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

3314 3315 3316 3317 3318
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->reada = -1;

J
Josef Bacik 已提交
3319 3320 3321 3322 3323
	/*
	 * 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.
	 */
3324
	if (root->ref_cows || root == root->fs_info->tree_root)
J
Josef Bacik 已提交
3325
		btrfs_drop_extent_cache(inode, (new_size + mask) & (~mask), (u64)-1, 0);
3326

3327 3328 3329 3330 3331 3332 3333 3334 3335
	/*
	 * 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);

3336
	key.objectid = ino;
C
Chris Mason 已提交
3337
	key.offset = (u64)-1;
3338 3339
	key.type = (u8)-1;

3340
search_again:
3341
	path->leave_spinning = 1;
3342
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3343 3344 3345 3346
	if (ret < 0) {
		err = ret;
		goto out;
	}
3347

3348
	if (ret > 0) {
3349 3350 3351
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
3352 3353
		if (path->slots[0] == 0)
			goto out;
3354 3355 3356
		path->slots[0]--;
	}

3357
	while (1) {
C
Chris Mason 已提交
3358
		fi = NULL;
3359 3360 3361
		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 已提交
3362

3363
		if (found_key.objectid != ino)
C
Chris Mason 已提交
3364
			break;
3365

3366
		if (found_type < min_type)
C
Chris Mason 已提交
3367 3368
			break;

3369
		item_end = found_key.offset;
C
Chris Mason 已提交
3370
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
3371
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
3372
					    struct btrfs_file_extent_item);
3373 3374
			extent_type = btrfs_file_extent_type(leaf, fi);
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3375
				item_end +=
3376
				    btrfs_file_extent_num_bytes(leaf, fi);
3377 3378
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
3379
									 fi);
C
Chris Mason 已提交
3380
			}
3381
			item_end--;
C
Chris Mason 已提交
3382
		}
3383 3384 3385 3386
		if (found_type > min_type) {
			del_item = 1;
		} else {
			if (item_end < new_size)
3387
				break;
3388 3389 3390 3391
			if (found_key.offset >= new_size)
				del_item = 1;
			else
				del_item = 0;
C
Chris Mason 已提交
3392 3393 3394
		}
		found_extent = 0;
		/* FIXME, shrink the extent if the ref count is only 1 */
3395 3396 3397 3398
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
3399
			u64 num_dec;
3400
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
3401
			if (!del_item) {
3402 3403
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
3404
				extent_num_bytes = new_size -
3405
					found_key.offset + root->sectorsize - 1;
3406 3407
				extent_num_bytes = extent_num_bytes &
					~((u64)root->sectorsize - 1);
3408 3409 3410
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
3411
					   extent_num_bytes);
3412
				if (root->ref_cows && extent_start != 0)
3413
					inode_sub_bytes(inode, num_dec);
3414
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
3415
			} else {
3416 3417 3418
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
3419 3420 3421
				extent_offset = found_key.offset -
					btrfs_file_extent_offset(leaf, fi);

C
Chris Mason 已提交
3422
				/* FIXME blocksize != 4096 */
3423
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
3424 3425
				if (extent_start != 0) {
					found_extent = 1;
3426
					if (root->ref_cows)
3427
						inode_sub_bytes(inode, num_dec);
3428
				}
C
Chris Mason 已提交
3429
			}
3430
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3431 3432 3433 3434 3435 3436 3437 3438
			/*
			 * 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) {
3439 3440 3441
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
3442 3443
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
3444 3445 3446
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
3447 3448
				btrfs_truncate_item(trans, root, path,
						    size, 1);
3449
			} else if (root->ref_cows) {
3450 3451
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
3452
			}
C
Chris Mason 已提交
3453
		}
3454
delete:
C
Chris Mason 已提交
3455
		if (del_item) {
3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
			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 {
3466
				BUG();
3467
			}
C
Chris Mason 已提交
3468 3469 3470
		} else {
			break;
		}
3471 3472
		if (found_extent && (root->ref_cows ||
				     root == root->fs_info->tree_root)) {
3473
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
3474
			ret = btrfs_free_extent(trans, root, extent_start,
3475 3476
						extent_num_bytes, 0,
						btrfs_header_owner(leaf),
3477
						ino, extent_offset, 0);
C
Chris Mason 已提交
3478 3479
			BUG_ON(ret);
		}
3480

3481 3482 3483 3484 3485 3486 3487 3488 3489
		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);
3490 3491 3492 3493 3494
				if (ret) {
					btrfs_abort_transaction(trans,
								root, ret);
					goto error;
				}
3495 3496
				pending_del_nr = 0;
			}
3497
			btrfs_release_path(path);
3498
			goto search_again;
3499 3500
		} else {
			path->slots[0]--;
3501
		}
C
Chris Mason 已提交
3502
	}
3503
out:
3504 3505 3506
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
3507 3508
		if (ret)
			btrfs_abort_transaction(trans, root, ret);
3509
	}
3510
error:
C
Chris Mason 已提交
3511
	btrfs_free_path(path);
3512
	return err;
C
Chris Mason 已提交
3513 3514 3515
}

/*
J
Josef Bacik 已提交
3516 3517 3518 3519 3520 3521 3522 3523 3524
 * 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 已提交
3525
 */
J
Josef Bacik 已提交
3526 3527
int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
			int front)
C
Chris Mason 已提交
3528
{
J
Josef Bacik 已提交
3529
	struct address_space *mapping = inode->i_mapping;
3530
	struct btrfs_root *root = BTRFS_I(inode)->root;
3531 3532
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
3533
	struct extent_state *cached_state = NULL;
3534
	char *kaddr;
3535
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
3536 3537 3538
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
3539
	gfp_t mask = btrfs_alloc_write_mask(mapping);
C
Chris Mason 已提交
3540
	int ret = 0;
3541
	u64 page_start;
3542
	u64 page_end;
C
Chris Mason 已提交
3543

J
Josef Bacik 已提交
3544 3545
	if ((offset & (blocksize - 1)) == 0 &&
	    (!len || ((len & (blocksize - 1)) == 0)))
C
Chris Mason 已提交
3546
		goto out;
3547
	ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
3548 3549
	if (ret)
		goto out;
C
Chris Mason 已提交
3550

3551
again:
3552
	page = find_or_create_page(mapping, index, mask);
3553
	if (!page) {
3554
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
3555
		ret = -ENOMEM;
C
Chris Mason 已提交
3556
		goto out;
3557
	}
3558 3559 3560 3561

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

C
Chris Mason 已提交
3562
	if (!PageUptodate(page)) {
3563
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
3564
		lock_page(page);
3565 3566 3567 3568 3569
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
3570 3571
		if (!PageUptodate(page)) {
			ret = -EIO;
3572
			goto out_unlock;
C
Chris Mason 已提交
3573 3574
		}
	}
3575
	wait_on_page_writeback(page);
3576

3577
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
3578 3579 3580 3581
	set_page_extent_mapped(page);

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
3582 3583
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
3584 3585
		unlock_page(page);
		page_cache_release(page);
3586
		btrfs_start_ordered_extent(inode, ordered, 1);
3587 3588 3589 3590
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

3591
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
3592 3593
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
3594
			  0, 0, &cached_state, GFP_NOFS);
3595

3596 3597
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
3598
	if (ret) {
3599 3600
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
3601 3602 3603
		goto out_unlock;
	}

3604
	if (offset != PAGE_CACHE_SIZE) {
J
Josef Bacik 已提交
3605 3606
		if (!len)
			len = PAGE_CACHE_SIZE - offset;
3607
		kaddr = kmap(page);
J
Josef Bacik 已提交
3608 3609 3610 3611
		if (front)
			memset(kaddr, 0, offset);
		else
			memset(kaddr + offset, 0, len);
3612 3613 3614
		flush_dcache_page(page);
		kunmap(page);
	}
3615
	ClearPageChecked(page);
3616
	set_page_dirty(page);
3617 3618
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
			     GFP_NOFS);
C
Chris Mason 已提交
3619

3620
out_unlock:
3621
	if (ret)
3622
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
3623 3624 3625 3626 3627 3628
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

3629 3630 3631 3632 3633 3634
/*
 * 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
 */
3635
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
C
Chris Mason 已提交
3636
{
3637 3638 3639
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3640
	struct extent_map *em = NULL;
3641
	struct extent_state *cached_state = NULL;
J
Josef Bacik 已提交
3642
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
3643
	u64 mask = root->sectorsize - 1;
3644
	u64 hole_start = (oldsize + mask) & ~mask;
3645 3646 3647 3648
	u64 block_end = (size + mask) & ~mask;
	u64 last_byte;
	u64 cur_offset;
	u64 hole_size;
3649
	int err = 0;
C
Chris Mason 已提交
3650

3651 3652 3653 3654 3655 3656 3657
	if (size <= hole_start)
		return 0;

	while (1) {
		struct btrfs_ordered_extent *ordered;
		btrfs_wait_ordered_range(inode, hole_start,
					 block_end - hole_start);
3658
		lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
3659
				 &cached_state);
3660 3661 3662
		ordered = btrfs_lookup_ordered_extent(inode, hole_start);
		if (!ordered)
			break;
3663 3664
		unlock_extent_cached(io_tree, hole_start, block_end - 1,
				     &cached_state, GFP_NOFS);
3665 3666
		btrfs_put_ordered_extent(ordered);
	}
C
Chris Mason 已提交
3667

3668 3669 3670 3671
	cur_offset = hole_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				block_end - cur_offset, 0);
3672 3673 3674 3675
		if (IS_ERR(em)) {
			err = PTR_ERR(em);
			break;
		}
3676 3677
		last_byte = min(extent_map_end(em), block_end);
		last_byte = (last_byte + mask) & ~mask;
3678
		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
J
Josef Bacik 已提交
3679
			struct extent_map *hole_em;
3680
			hole_size = last_byte - cur_offset;
3681

3682
			trans = btrfs_start_transaction(root, 3);
3683 3684
			if (IS_ERR(trans)) {
				err = PTR_ERR(trans);
3685
				break;
3686
			}
3687

J
Josef Bacik 已提交
3688 3689
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
3690
						 cur_offset + hole_size, 1);
3691
			if (err) {
3692
				btrfs_abort_transaction(trans, root, err);
3693
				btrfs_end_transaction(trans, root);
3694
				break;
3695
			}
3696

3697
			err = btrfs_insert_file_extent(trans, root,
3698
					btrfs_ino(inode), cur_offset, 0,
3699 3700
					0, hole_size, 0, hole_size,
					0, 0, 0);
3701
			if (err) {
3702
				btrfs_abort_transaction(trans, root, err);
3703
				btrfs_end_transaction(trans, root);
3704
				break;
3705
			}
3706

J
Josef Bacik 已提交
3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717
			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;
3718

J
Josef Bacik 已提交
3719 3720
			hole_em->block_start = EXTENT_MAP_HOLE;
			hole_em->block_len = 0;
3721
			hole_em->orig_block_len = 0;
J
Josef Bacik 已提交
3722 3723 3724
			hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
			hole_em->compress_type = BTRFS_COMPRESS_NONE;
			hole_em->generation = trans->transid;
3725

J
Josef Bacik 已提交
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
			while (1) {
				write_lock(&em_tree->lock);
				err = add_extent_mapping(em_tree, hole_em);
				if (!err)
					list_move(&hole_em->list,
						  &em_tree->modified_extents);
				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:
3741
			btrfs_update_inode(trans, root, inode);
3742
			btrfs_end_transaction(trans, root);
3743 3744
		}
		free_extent_map(em);
3745
		em = NULL;
3746
		cur_offset = last_byte;
3747
		if (cur_offset >= block_end)
3748 3749
			break;
	}
3750

3751
	free_extent_map(em);
3752 3753
	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
			     GFP_NOFS);
3754 3755
	return err;
}
C
Chris Mason 已提交
3756

3757
static int btrfs_setsize(struct inode *inode, loff_t newsize)
3758
{
3759 3760
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
3761
	loff_t oldsize = i_size_read(inode);
3762 3763
	int ret;

3764
	if (newsize == oldsize)
3765 3766
		return 0;

3767 3768 3769
	if (newsize > oldsize) {
		truncate_pagecache(inode, oldsize, newsize);
		ret = btrfs_cont_expand(inode, oldsize, newsize);
3770
		if (ret)
3771 3772
			return ret;

3773 3774 3775 3776 3777 3778 3779
		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);
3780
		btrfs_end_transaction(trans, root);
3781
	} else {
3782

3783 3784 3785 3786 3787 3788
		/*
		 * 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)
3789 3790
			set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
				&BTRFS_I(inode)->runtime_flags);
3791

3792 3793 3794
		/* we don't support swapfiles, so vmtruncate shouldn't fail */
		truncate_setsize(inode, newsize);
		ret = btrfs_truncate(inode);
3795 3796
	}

3797
	return ret;
3798 3799
}

3800 3801 3802
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
3803
	struct btrfs_root *root = BTRFS_I(inode)->root;
3804
	int err;
C
Chris Mason 已提交
3805

3806 3807 3808
	if (btrfs_root_readonly(root))
		return -EROFS;

3809 3810 3811
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
3812

3813
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
3814
		err = btrfs_setsize(inode, attr->ia_size);
3815 3816
		if (err)
			return err;
C
Chris Mason 已提交
3817
	}
3818

C
Christoph Hellwig 已提交
3819 3820
	if (attr->ia_valid) {
		setattr_copy(inode, attr);
3821
		inode_inc_iversion(inode);
3822
		err = btrfs_dirty_inode(inode);
C
Christoph Hellwig 已提交
3823

3824
		if (!err && attr->ia_valid & ATTR_MODE)
C
Christoph Hellwig 已提交
3825 3826
			err = btrfs_acl_chmod(inode);
	}
J
Josef Bacik 已提交
3827

C
Chris Mason 已提交
3828 3829
	return err;
}
3830

3831
void btrfs_evict_inode(struct inode *inode)
C
Chris Mason 已提交
3832 3833 3834
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
3835
	struct btrfs_block_rsv *rsv, *global_rsv;
3836
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
3837 3838
	int ret;

3839 3840
	trace_btrfs_inode_evict(inode);

C
Chris Mason 已提交
3841
	truncate_inode_pages(&inode->i_data, 0);
3842
	if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
3843
			       btrfs_is_free_space_inode(inode)))
3844 3845
		goto no_delete;

C
Chris Mason 已提交
3846
	if (is_bad_inode(inode)) {
3847
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
3848 3849
		goto no_delete;
	}
3850
	/* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
C
Chris Mason 已提交
3851
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
3852

3853
	if (root->fs_info->log_root_recovering) {
3854
		BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3855
				 &BTRFS_I(inode)->runtime_flags));
3856 3857 3858
		goto no_delete;
	}

3859 3860 3861 3862 3863
	if (inode->i_nlink > 0) {
		BUG_ON(btrfs_root_refs(&root->root_item) != 0);
		goto no_delete;
	}

3864
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
3865 3866 3867 3868
	if (!rsv) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}
3869
	rsv->size = min_size;
3870
	rsv->failfast = 1;
3871
	global_rsv = &root->fs_info->global_block_rsv;
3872

3873
	btrfs_i_size_write(inode, 0);
3874

3875
	/*
3876 3877 3878 3879
	 * 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.
3880
	 */
3881
	while (1) {
3882 3883
		ret = btrfs_block_rsv_refill(root, rsv, min_size,
					     BTRFS_RESERVE_FLUSH_LIMIT);
3884 3885 3886 3887 3888 3889 3890 3891

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

		if (ret) {
3894
			printk(KERN_WARNING "Could not get space for a "
3895
			       "delete, will truncate on mount %d\n", ret);
3896 3897 3898
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
3899
		}
3900

3901
		trans = btrfs_start_transaction_lflush(root, 1);
3902 3903 3904 3905
		if (IS_ERR(trans)) {
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
3906
		}
3907

3908 3909
		trans->block_rsv = rsv;

3910
		ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
3911
		if (ret != -ENOSPC)
3912
			break;
3913

3914 3915 3916 3917
		trans->block_rsv = &root->fs_info->trans_block_rsv;
		ret = btrfs_update_inode(trans, root, inode);
		BUG_ON(ret);

3918 3919
		btrfs_end_transaction(trans, root);
		trans = NULL;
3920
		btrfs_btree_balance_dirty(root);
3921
	}
3922

3923 3924
	btrfs_free_block_rsv(root, rsv);

3925
	if (ret == 0) {
3926
		trans->block_rsv = root->orphan_block_rsv;
3927 3928 3929
		ret = btrfs_orphan_del(trans, inode);
		BUG_ON(ret);
	}
3930

3931
	trans->block_rsv = &root->fs_info->trans_block_rsv;
3932 3933
	if (!(root == root->fs_info->tree_root ||
	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
3934
		btrfs_return_ino(root, btrfs_ino(inode));
3935

3936
	btrfs_end_transaction(trans, root);
3937
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
3938
no_delete:
3939
	clear_inode(inode);
3940
	return;
C
Chris Mason 已提交
3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954
}

/*
 * 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;
3955
	int ret = 0;
C
Chris Mason 已提交
3956 3957

	path = btrfs_alloc_path();
3958 3959
	if (!path)
		return -ENOMEM;
3960

3961
	di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
C
Chris Mason 已提交
3962
				    namelen, 0);
3963 3964
	if (IS_ERR(di))
		ret = PTR_ERR(di);
3965

3966
	if (IS_ERR_OR_NULL(di))
3967
		goto out_err;
3968

3969
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
3970 3971 3972
out:
	btrfs_free_path(path);
	return ret;
3973 3974 3975
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
3976 3977 3978 3979 3980 3981 3982 3983
}

/*
 * 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,
3984 3985 3986 3987
				    struct inode *dir,
				    struct dentry *dentry,
				    struct btrfs_key *location,
				    struct btrfs_root **sub_root)
C
Chris Mason 已提交
3988
{
3989 3990 3991 3992 3993 3994
	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 已提交
3995

3996 3997 3998 3999 4000
	path = btrfs_alloc_path();
	if (!path) {
		err = -ENOMEM;
		goto out;
	}
C
Chris Mason 已提交
4001

4002 4003 4004 4005 4006 4007 4008 4009 4010
	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 已提交
4011

4012 4013
	leaf = path->nodes[0];
	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
4014
	if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
4015 4016
	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
		goto out;
C
Chris Mason 已提交
4017

4018 4019 4020 4021 4022 4023
	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
				   (unsigned long)(ref + 1),
				   dentry->d_name.len);
	if (ret)
		goto out;

4024
	btrfs_release_path(path);
4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044

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

	if (btrfs_root_refs(&new_root->root_item) == 0) {
		err = -ENOENT;
		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 已提交
4045 4046
}

4047 4048 4049 4050
static void inode_tree_add(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_inode *entry;
4051 4052
	struct rb_node **p;
	struct rb_node *parent;
4053
	u64 ino = btrfs_ino(inode);
4054 4055 4056
again:
	p = &root->inode_tree.rb_node;
	parent = NULL;
4057

A
Al Viro 已提交
4058
	if (inode_unhashed(inode))
4059 4060
		return;

4061 4062 4063 4064 4065
	spin_lock(&root->inode_lock);
	while (*p) {
		parent = *p;
		entry = rb_entry(parent, struct btrfs_inode, rb_node);

4066
		if (ino < btrfs_ino(&entry->vfs_inode))
4067
			p = &parent->rb_left;
4068
		else if (ino > btrfs_ino(&entry->vfs_inode))
4069
			p = &parent->rb_right;
4070 4071
		else {
			WARN_ON(!(entry->vfs_inode.i_state &
4072
				  (I_WILL_FREE | I_FREEING)));
4073 4074 4075 4076
			rb_erase(parent, &root->inode_tree);
			RB_CLEAR_NODE(parent);
			spin_unlock(&root->inode_lock);
			goto again;
4077 4078 4079 4080 4081 4082 4083 4084 4085 4086
		}
	}
	rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
	rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
	spin_unlock(&root->inode_lock);
}

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

4089
	spin_lock(&root->inode_lock);
4090 4091 4092
	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);
4093
		empty = RB_EMPTY_ROOT(&root->inode_tree);
4094
	}
4095
	spin_unlock(&root->inode_lock);
4096

4097 4098 4099 4100 4101 4102 4103 4104
	/*
	 * Free space cache has inodes in the tree root, but the tree root has a
	 * root_refs of 0, so this could end up dropping the tree root as a
	 * snapshot, so we need the extra !root->fs_info->tree_root check to
	 * make sure we don't drop it.
	 */
	if (empty && btrfs_root_refs(&root->root_item) == 0 &&
	    root != root->fs_info->tree_root) {
4105 4106 4107 4108 4109 4110 4111 4112 4113
		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);
	}
}

4114
void btrfs_invalidate_inodes(struct btrfs_root *root)
4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
{
	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);

4132
		if (objectid < btrfs_ino(&entry->vfs_inode))
4133
			node = node->rb_left;
4134
		else if (objectid > btrfs_ino(&entry->vfs_inode))
4135 4136 4137 4138 4139 4140 4141
			node = node->rb_right;
		else
			break;
	}
	if (!node) {
		while (prev) {
			entry = rb_entry(prev, struct btrfs_inode, rb_node);
4142
			if (objectid <= btrfs_ino(&entry->vfs_inode)) {
4143 4144 4145 4146 4147 4148 4149 4150
				node = prev;
				break;
			}
			prev = rb_next(prev);
		}
	}
	while (node) {
		entry = rb_entry(node, struct btrfs_inode, rb_node);
4151
		objectid = btrfs_ino(&entry->vfs_inode) + 1;
4152 4153 4154 4155 4156 4157
		inode = igrab(&entry->vfs_inode);
		if (inode) {
			spin_unlock(&root->inode_lock);
			if (atomic_read(&inode->i_count) > 1)
				d_prune_aliases(inode);
			/*
4158
			 * btrfs_drop_inode will have it removed from
4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
			 * 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);
4174 4175
}

4176 4177 4178 4179 4180
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 已提交
4181 4182 4183 4184 4185 4186
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
4187
	return args->ino == btrfs_ino(inode) &&
4188
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
4189 4190
}

4191 4192 4193
static struct inode *btrfs_iget_locked(struct super_block *s,
				       u64 objectid,
				       struct btrfs_root *root)
C
Chris Mason 已提交
4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205
{
	struct inode *inode;
	struct btrfs_iget_args args;
	args.ino = objectid;
	args.root = root;

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

B
Balaji Rao 已提交
4206 4207 4208 4209
/* 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,
4210
			 struct btrfs_root *root, int *new)
B
Balaji Rao 已提交
4211 4212 4213 4214 4215
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
4216
		return ERR_PTR(-ENOMEM);
B
Balaji Rao 已提交
4217 4218 4219 4220 4221

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
4222 4223 4224 4225 4226 4227
		if (!is_bad_inode(inode)) {
			inode_tree_add(inode);
			unlock_new_inode(inode);
			if (new)
				*new = 1;
		} else {
4228 4229 4230
			unlock_new_inode(inode);
			iput(inode);
			inode = ERR_PTR(-ESTALE);
4231 4232 4233
		}
	}

B
Balaji Rao 已提交
4234 4235 4236
	return inode;
}

4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247
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));
4248
	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
4249 4250

	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
4251
	inode->i_op = &btrfs_dir_ro_inode_operations;
4252 4253 4254 4255 4256 4257 4258
	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;
}

4259
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
4260
{
4261
	struct inode *inode;
4262
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
4263 4264
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
4265
	int index;
4266
	int ret = 0;
C
Chris Mason 已提交
4267 4268 4269

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

4271 4272 4273 4274
	if (unlikely(d_need_lookup(dentry))) {
		memcpy(&location, dentry->d_fsdata, sizeof(struct btrfs_key));
		kfree(dentry->d_fsdata);
		dentry->d_fsdata = NULL;
4275 4276
		/* This thing is hashed, drop it for now */
		d_drop(dentry);
4277 4278 4279
	} else {
		ret = btrfs_inode_by_name(dir, dentry, &location);
	}
4280

C
Chris Mason 已提交
4281 4282
	if (ret < 0)
		return ERR_PTR(ret);
4283

4284 4285 4286 4287
	if (location.objectid == 0)
		return NULL;

	if (location.type == BTRFS_INODE_ITEM_KEY) {
4288
		inode = btrfs_iget(dir->i_sb, &location, root, NULL);
4289 4290 4291 4292 4293
		return inode;
	}

	BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);

4294
	index = srcu_read_lock(&root->fs_info->subvol_srcu);
4295 4296 4297 4298 4299 4300 4301 4302
	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 {
4303
		inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
C
Chris Mason 已提交
4304
	}
4305 4306
	srcu_read_unlock(&root->fs_info->subvol_srcu, index);

4307
	if (!IS_ERR(inode) && root != sub_root) {
4308 4309
		down_read(&root->fs_info->cleanup_work_sem);
		if (!(inode->i_sb->s_flags & MS_RDONLY))
4310
			ret = btrfs_orphan_cleanup(sub_root);
4311
		up_read(&root->fs_info->cleanup_work_sem);
4312 4313
		if (ret)
			inode = ERR_PTR(ret);
4314 4315
	}

4316 4317 4318
	return inode;
}

4319
static int btrfs_dentry_delete(const struct dentry *dentry)
4320 4321
{
	struct btrfs_root *root;
4322
	struct inode *inode = dentry->d_inode;
4323

4324 4325
	if (!inode && !IS_ROOT(dentry))
		inode = dentry->d_parent->d_inode;
4326

4327 4328
	if (inode) {
		root = BTRFS_I(inode)->root;
4329 4330
		if (btrfs_root_refs(&root->root_item) == 0)
			return 1;
4331 4332 4333

		if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
			return 1;
4334
	}
4335 4336 4337
	return 0;
}

4338 4339 4340 4341 4342 4343
static void btrfs_dentry_release(struct dentry *dentry)
{
	if (dentry->d_fsdata)
		kfree(dentry->d_fsdata);
}

4344
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
4345
				   unsigned int flags)
4346
{
4347 4348 4349 4350 4351 4352 4353 4354 4355
	struct dentry *ret;

	ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
	if (unlikely(d_need_lookup(dentry))) {
		spin_lock(&dentry->d_lock);
		dentry->d_flags &= ~DCACHE_NEED_LOOKUP;
		spin_unlock(&dentry->d_lock);
	}
	return ret;
C
Chris Mason 已提交
4356 4357
}

4358
unsigned char btrfs_filetype_table[] = {
C
Chris Mason 已提交
4359 4360 4361
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

4362 4363
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
4364
{
4365
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
4366 4367 4368 4369
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
4370
	struct btrfs_key found_key;
C
Chris Mason 已提交
4371
	struct btrfs_path *path;
4372 4373
	struct list_head ins_list;
	struct list_head del_list;
C
Chris Mason 已提交
4374
	int ret;
4375
	struct extent_buffer *leaf;
C
Chris Mason 已提交
4376 4377 4378 4379 4380 4381 4382
	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;
4383 4384 4385
	char tmp_name[32];
	char *name_ptr;
	int name_len;
4386
	int is_curr = 0;	/* filp->f_pos points to the current index? */
C
Chris Mason 已提交
4387 4388 4389 4390

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

4392 4393
	/* special case for "." */
	if (filp->f_pos == 0) {
4394 4395
		over = filldir(dirent, ".", 1,
			       filp->f_pos, btrfs_ino(inode), DT_DIR);
4396 4397 4398 4399 4400 4401
		if (over)
			return 0;
		filp->f_pos = 1;
	}
	/* special case for .., just use the back ref */
	if (filp->f_pos == 1) {
4402
		u64 pino = parent_ino(filp->f_path.dentry);
4403
		over = filldir(dirent, "..", 2,
4404
			       filp->f_pos, pino, DT_DIR);
4405
		if (over)
4406
			return 0;
4407 4408
		filp->f_pos = 2;
	}
4409
	path = btrfs_alloc_path();
4410 4411
	if (!path)
		return -ENOMEM;
C
Chris Mason 已提交
4412

4413
	path->reada = 1;
4414

4415 4416 4417 4418 4419 4420
	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 已提交
4421 4422
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
4423
	key.objectid = btrfs_ino(inode);
4424

C
Chris Mason 已提交
4425 4426 4427
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
4428 4429

	while (1) {
4430
		leaf = path->nodes[0];
C
Chris Mason 已提交
4431
		slot = path->slots[0];
4432 4433 4434 4435 4436 4437 4438
		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 已提交
4439
		}
4440

4441 4442 4443 4444
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
4445
			break;
4446
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
4447
			break;
4448
		if (found_key.offset < filp->f_pos)
4449
			goto next;
4450 4451 4452 4453
		if (key_type == BTRFS_DIR_INDEX_KEY &&
		    btrfs_should_delete_dir_index(&del_list,
						  found_key.offset))
			goto next;
4454 4455

		filp->f_pos = found_key.offset;
4456
		is_curr = 1;
4457

C
Chris Mason 已提交
4458 4459
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
4460
		di_total = btrfs_item_size(leaf, item);
4461 4462

		while (di_cur < di_total) {
4463 4464
			struct btrfs_key location;

4465 4466 4467
			if (verify_dir_item(root, leaf, di))
				break;

4468
			name_len = btrfs_dir_name_len(leaf, di);
4469
			if (name_len <= sizeof(tmp_name)) {
4470 4471 4472
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
4473 4474 4475 4476
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
4477 4478 4479 4480 4481 4482
			}
			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);
4483

4484

4485
			/* is this a reference to our own snapshot? If so
A
Arne Jansen 已提交
4486 4487 4488 4489 4490 4491 4492
			 * 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.
4493 4494 4495 4496 4497 4498
			 */
			if (location.type == BTRFS_ROOT_ITEM_KEY &&
			    location.objectid == root->root_key.objectid) {
				over = 0;
				goto skip;
			}
4499
			over = filldir(dirent, name_ptr, name_len,
4500
				       found_key.offset, location.objectid,
C
Chris Mason 已提交
4501
				       d_type);
4502

4503
skip:
4504 4505 4506
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
4507 4508
			if (over)
				goto nopos;
J
Josef Bacik 已提交
4509
			di_len = btrfs_dir_name_len(leaf, di) +
4510
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
4511 4512 4513
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
4514 4515
next:
		path->slots[0]++;
C
Chris Mason 已提交
4516
	}
4517

4518 4519 4520 4521 4522 4523 4524 4525 4526
	if (key_type == BTRFS_DIR_INDEX_KEY) {
		if (is_curr)
			filp->f_pos++;
		ret = btrfs_readdir_delayed_dir_index(filp, dirent, filldir,
						      &ins_list);
		if (ret)
			goto nopos;
	}

4527
	/* Reached end of directory/root. Bump pos past the last item. */
4528
	if (key_type == BTRFS_DIR_INDEX_KEY)
4529 4530 4531 4532 4533
		/*
		 * 32-bit glibc will use getdents64, but then strtol -
		 * so the last number we can serve is this.
		 */
		filp->f_pos = 0x7fffffff;
4534 4535
	else
		filp->f_pos++;
C
Chris Mason 已提交
4536 4537 4538
nopos:
	ret = 0;
err:
4539 4540
	if (key_type == BTRFS_DIR_INDEX_KEY)
		btrfs_put_delayed_items(&ins_list, &del_list);
C
Chris Mason 已提交
4541 4542 4543 4544
	btrfs_free_path(path);
	return ret;
}

4545
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
C
Chris Mason 已提交
4546 4547 4548 4549
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;
4550
	bool nolock = false;
C
Chris Mason 已提交
4551

4552
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
4553 4554
		return 0;

4555
	if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
4556
		nolock = true;
4557

4558
	if (wbc->sync_mode == WB_SYNC_ALL) {
4559
		if (nolock)
4560
			trans = btrfs_join_transaction_nolock(root);
4561
		else
4562
			trans = btrfs_join_transaction(root);
4563 4564
		if (IS_ERR(trans))
			return PTR_ERR(trans);
4565
		ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
4566 4567 4568 4569 4570
	}
	return ret;
}

/*
4571
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
4572 4573 4574 4575
 * 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.
 */
4576
int btrfs_dirty_inode(struct inode *inode)
C
Chris Mason 已提交
4577 4578 4579
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
4580 4581
	int ret;

4582
	if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
4583
		return 0;
C
Chris Mason 已提交
4584

4585
	trans = btrfs_join_transaction(root);
4586 4587
	if (IS_ERR(trans))
		return PTR_ERR(trans);
4588 4589

	ret = btrfs_update_inode(trans, root, inode);
4590 4591 4592 4593
	if (ret && ret == -ENOSPC) {
		/* whoops, lets try again with the full transaction */
		btrfs_end_transaction(trans, root);
		trans = btrfs_start_transaction(root, 1);
4594 4595
		if (IS_ERR(trans))
			return PTR_ERR(trans);
4596

4597 4598
		ret = btrfs_update_inode(trans, root, inode);
	}
C
Chris Mason 已提交
4599
	btrfs_end_transaction(trans, root);
4600 4601
	if (BTRFS_I(inode)->delayed_node)
		btrfs_balance_delayed_items(root);
4602 4603 4604 4605 4606 4607 4608 4609

	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.
 */
4610 4611
static int btrfs_update_time(struct inode *inode, struct timespec *now,
			     int flags)
4612
{
4613 4614 4615 4616 4617
	struct btrfs_root *root = BTRFS_I(inode)->root;

	if (btrfs_root_readonly(root))
		return -EROFS;

4618
	if (flags & S_VERSION)
4619
		inode_inc_iversion(inode);
4620 4621 4622 4623 4624 4625 4626
	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 已提交
4627 4628
}

4629 4630 4631 4632 4633
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
4634 4635 4636 4637 4638 4639 4640 4641
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;

4642
	key.objectid = btrfs_ino(inode);
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
	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]);

4674
	if (found_key.objectid != btrfs_ino(inode) ||
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685
	    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;
}

4686 4687 4688 4689
/*
 * 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
 */
4690
int btrfs_set_inode_index(struct inode *dir, u64 *index)
4691 4692 4693 4694
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
4695 4696 4697 4698 4699 4700
		ret = btrfs_inode_delayed_dir_index_count(dir);
		if (ret) {
			ret = btrfs_set_inode_index_count(dir);
			if (ret)
				return ret;
		}
4701 4702
	}

4703
	*index = BTRFS_I(dir)->index_cnt;
4704 4705 4706 4707 4708
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
4709 4710
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
4711
				     struct inode *dir,
4712
				     const char *name, int name_len,
4713 4714
				     u64 ref_objectid, u64 objectid,
				     umode_t mode, u64 *index)
C
Chris Mason 已提交
4715 4716
{
	struct inode *inode;
4717
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
4718
	struct btrfs_key *location;
4719
	struct btrfs_path *path;
4720 4721 4722 4723
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
4724 4725 4726
	int ret;
	int owner;

4727
	path = btrfs_alloc_path();
4728 4729
	if (!path)
		return ERR_PTR(-ENOMEM);
4730

C
Chris Mason 已提交
4731
	inode = new_inode(root->fs_info->sb);
4732 4733
	if (!inode) {
		btrfs_free_path(path);
C
Chris Mason 已提交
4734
		return ERR_PTR(-ENOMEM);
4735
	}
C
Chris Mason 已提交
4736

4737 4738 4739 4740 4741 4742
	/*
	 * we have to initialize this early, so we can reclaim the inode
	 * number if we fail afterwards in this function.
	 */
	inode->i_ino = objectid;

4743
	if (dir) {
4744 4745
		trace_btrfs_inode_request(dir);

4746
		ret = btrfs_set_inode_index(dir, index);
4747
		if (ret) {
4748
			btrfs_free_path(path);
4749
			iput(inode);
4750
			return ERR_PTR(ret);
4751
		}
4752 4753 4754 4755 4756 4757 4758
	}
	/*
	 * 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 已提交
4759
	BTRFS_I(inode)->root = root;
4760
	BTRFS_I(inode)->generation = trans->transid;
4761
	inode->i_generation = BTRFS_I(inode)->generation;
4762

J
Josef Bacik 已提交
4763 4764 4765 4766 4767 4768 4769 4770
	/*
	 * 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);

4771
	if (S_ISDIR(mode))
C
Chris Mason 已提交
4772 4773 4774
		owner = 0;
	else
		owner = 1;
4775 4776 4777 4778 4779

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

M
Mark Fasheh 已提交
4780 4781 4782 4783 4784 4785
	/*
	 * 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.
	 */
4786 4787 4788 4789 4790 4791 4792
	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);

4793
	path->leave_spinning = 1;
4794 4795
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
4796 4797
		goto fail;

4798
	inode_init_owner(inode, dir, mode);
4799
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
4800
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
4801 4802
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
4803 4804
	memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
			     sizeof(*inode_item));
4805
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
4806 4807 4808 4809

	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);
4810
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
4811 4812 4813
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

4814 4815 4816
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
4817 4818 4819 4820 4821
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

4822 4823
	btrfs_inherit_iflags(inode, dir);

4824
	if (S_ISREG(mode)) {
4825 4826
		if (btrfs_test_opt(root, NODATASUM))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
4827 4828
		if (btrfs_test_opt(root, NODATACOW) ||
		    (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
4829 4830 4831
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
	}

C
Chris Mason 已提交
4832
	insert_inode_hash(inode);
4833
	inode_tree_add(inode);
4834 4835

	trace_btrfs_inode_new(inode);
4836
	btrfs_set_inode_last_trans(trans, inode);
4837

4838 4839
	btrfs_update_root_times(trans, root);

C
Chris Mason 已提交
4840
	return inode;
4841
fail:
4842 4843
	if (dir)
		BTRFS_I(dir)->index_cnt--;
4844
	btrfs_free_path(path);
4845
	iput(inode);
4846
	return ERR_PTR(ret);
C
Chris Mason 已提交
4847 4848 4849 4850 4851 4852 4853
}

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

4854 4855 4856 4857 4858 4859
/*
 * 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.
 */
4860 4861 4862
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 已提交
4863
{
4864
	int ret = 0;
C
Chris Mason 已提交
4865
	struct btrfs_key key;
4866
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
4867 4868
	u64 ino = btrfs_ino(inode);
	u64 parent_ino = btrfs_ino(parent_inode);
4869

4870
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
4871 4872
		memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
	} else {
4873
		key.objectid = ino;
4874 4875 4876 4877
		btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
		key.offset = 0;
	}

4878
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
4879 4880
		ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
					 key.objectid, root->root_key.objectid,
4881
					 parent_ino, index, name, name_len);
4882
	} else if (add_backref) {
4883 4884
		ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
					     parent_ino, index);
4885
	}
C
Chris Mason 已提交
4886

4887 4888 4889
	/* Nothing to clean up yet */
	if (ret)
		return ret;
4890

4891 4892 4893 4894 4895 4896 4897 4898
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode, &key,
				    btrfs_inode_type(inode), index);
	if (ret == -EEXIST)
		goto fail_dir_item;
	else if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		return ret;
C
Chris Mason 已提交
4899
	}
4900 4901 4902

	btrfs_i_size_write(parent_inode, parent_inode->i_size +
			   name_len * 2);
4903
	inode_inc_iversion(parent_inode);
4904 4905 4906 4907
	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 已提交
4908
	return ret;
4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925

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 已提交
4926 4927 4928
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
4929 4930
			    struct inode *dir, struct dentry *dentry,
			    struct inode *inode, int backref, u64 index)
C
Chris Mason 已提交
4931
{
4932 4933 4934
	int err = btrfs_add_link(trans, dir, inode,
				 dentry->d_name.name, dentry->d_name.len,
				 backref, index);
C
Chris Mason 已提交
4935 4936 4937 4938 4939
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
4940
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
4941
			umode_t mode, dev_t rdev)
J
Josef Bacik 已提交
4942 4943 4944
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
4945
	struct inode *inode = NULL;
J
Josef Bacik 已提交
4946 4947 4948
	int err;
	int drop_inode = 0;
	u64 objectid;
4949
	u64 index = 0;
J
Josef Bacik 已提交
4950 4951 4952 4953

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

4954 4955 4956 4957 4958
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
4959 4960 4961
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
4962

4963 4964 4965 4966
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

4967
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4968
				dentry->d_name.len, btrfs_ino(dir), objectid,
4969
				mode, &index);
4970 4971
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
J
Josef Bacik 已提交
4972
		goto out_unlock;
4973
	}
J
Josef Bacik 已提交
4974

4975
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
4976 4977 4978 4979 4980
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

4981 4982 4983 4984 4985 4986
	err = btrfs_update_inode(trans, root, inode);
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

4987 4988 4989 4990 4991 4992 4993 4994
	/*
	* 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;
4995
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
J
Josef Bacik 已提交
4996 4997 4998 4999
	if (err)
		drop_inode = 1;
	else {
		init_special_inode(inode, inode->i_mode, rdev);
5000
		btrfs_update_inode(trans, root, inode);
5001
		d_instantiate(dentry, inode);
J
Josef Bacik 已提交
5002 5003
	}
out_unlock:
5004
	btrfs_end_transaction(trans, root);
5005
	btrfs_btree_balance_dirty(root);
J
Josef Bacik 已提交
5006 5007 5008 5009 5010 5011 5012
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
	return err;
}

C
Chris Mason 已提交
5013
static int btrfs_create(struct inode *dir, struct dentry *dentry,
5014
			umode_t mode, bool excl)
C
Chris Mason 已提交
5015 5016 5017
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
5018
	struct inode *inode = NULL;
5019
	int drop_inode_on_err = 0;
5020
	int err;
C
Chris Mason 已提交
5021
	u64 objectid;
5022
	u64 index = 0;
C
Chris Mason 已提交
5023

5024 5025 5026 5027 5028
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
5029 5030 5031
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
5032

5033 5034 5035 5036
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

5037
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
5038
				dentry->d_name.len, btrfs_ino(dir), objectid,
5039
				mode, &index);
5040 5041
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
5042
		goto out_unlock;
5043
	}
5044
	drop_inode_on_err = 1;
C
Chris Mason 已提交
5045

5046
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5047
	if (err)
J
Josef Bacik 已提交
5048 5049
		goto out_unlock;

5050 5051 5052 5053 5054 5055 5056 5057 5058
	/*
	* 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;

5059
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
5060
	if (err)
5061 5062 5063 5064 5065 5066 5067
		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 已提交
5068
out_unlock:
5069
	btrfs_end_transaction(trans, root);
5070
	if (err && drop_inode_on_err) {
C
Chris Mason 已提交
5071 5072 5073
		inode_dec_link_count(inode);
		iput(inode);
	}
5074
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5075 5076 5077 5078 5079 5080 5081 5082 5083
	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;
5084
	u64 index;
C
Chris Mason 已提交
5085 5086 5087
	int err;
	int drop_inode = 0;

5088 5089
	/* do not allow sys_link's with other subvols of the same device */
	if (root->objectid != BTRFS_I(inode)->root->objectid)
5090
		return -EXDEV;
5091

M
Mark Fasheh 已提交
5092
	if (inode->i_nlink >= BTRFS_LINK_MAX)
5093
		return -EMLINK;
5094

5095
	err = btrfs_set_inode_index(dir, &index);
5096 5097 5098
	if (err)
		goto fail;

5099
	/*
5100
	 * 2 items for inode and inode ref
5101
	 * 2 items for dir items
5102
	 * 1 item for parent inode
5103
	 */
5104
	trans = btrfs_start_transaction(root, 5);
5105 5106 5107 5108
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto fail;
	}
5109

5110
	btrfs_inc_nlink(inode);
5111
	inode_inc_iversion(inode);
5112
	inode->i_ctime = CURRENT_TIME;
A
Al Viro 已提交
5113
	ihold(inode);
5114
	set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
5115

5116
	err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
5117

5118
	if (err) {
5119
		drop_inode = 1;
5120
	} else {
5121
		struct dentry *parent = dentry->d_parent;
5122
		err = btrfs_update_inode(trans, root, inode);
5123 5124
		if (err)
			goto fail;
5125
		d_instantiate(dentry, inode);
5126
		btrfs_log_new_name(trans, inode, NULL, parent);
5127
	}
C
Chris Mason 已提交
5128

5129
	btrfs_end_transaction(trans, root);
5130
fail:
C
Chris Mason 已提交
5131 5132 5133 5134
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
5135
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5136 5137 5138
	return err;
}

5139
static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
C
Chris Mason 已提交
5140
{
5141
	struct inode *inode = NULL;
C
Chris Mason 已提交
5142 5143 5144 5145
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
5146
	u64 objectid = 0;
5147
	u64 index = 0;
C
Chris Mason 已提交
5148

5149 5150 5151 5152 5153
	/*
	 * 2 items for inode and ref
	 * 2 items for dir items
	 * 1 for xattr if selinux is on
	 */
5154 5155 5156
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
5157

5158 5159 5160 5161
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_fail;

5162
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
5163
				dentry->d_name.len, btrfs_ino(dir), objectid,
5164
				S_IFDIR | mode, &index);
C
Chris Mason 已提交
5165 5166 5167 5168
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
5169

C
Chris Mason 已提交
5170
	drop_on_err = 1;
J
Josef Bacik 已提交
5171

5172
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
5173 5174 5175
	if (err)
		goto out_fail;

C
Chris Mason 已提交
5176 5177 5178
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

5179
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
5180 5181 5182
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
5183

5184 5185
	err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
			     dentry->d_name.len, 0, index);
C
Chris Mason 已提交
5186 5187
	if (err)
		goto out_fail;
5188

C
Chris Mason 已提交
5189 5190 5191 5192
	d_instantiate(dentry, inode);
	drop_on_err = 0;

out_fail:
5193
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
5194 5195
	if (drop_on_err)
		iput(inode);
5196
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
5197 5198 5199
	return err;
}

5200 5201 5202 5203
/* 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.
 */
5204 5205
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
5206 5207
				struct extent_map *em,
				u64 map_start, u64 map_len)
5208 5209 5210
{
	u64 start_diff;

5211 5212 5213 5214
	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;
5215 5216
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
5217
		em->block_start += start_diff;
5218 5219
		em->block_len -= start_diff;
	}
5220
	return add_extent_mapping(em_tree, em);
5221 5222
}

5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233
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;
5234
	int compress_type;
5235 5236

	WARN_ON(pg_offset != 0);
5237
	compress_type = btrfs_file_extent_compression(leaf, item);
5238 5239 5240 5241
	max_size = btrfs_file_extent_ram_bytes(leaf, item);
	inline_size = btrfs_file_extent_inline_item_len(leaf,
					btrfs_item_nr(leaf, path->slots[0]));
	tmp = kmalloc(inline_size, GFP_NOFS);
5242 5243
	if (!tmp)
		return -ENOMEM;
5244 5245 5246 5247
	ptr = btrfs_file_extent_inline_start(item);

	read_extent_buffer(leaf, tmp, ptr, inline_size);

5248
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
5249 5250
	ret = btrfs_decompress(compress_type, tmp, page,
			       extent_offset, inline_size, max_size);
5251
	if (ret) {
5252
		char *kaddr = kmap_atomic(page);
5253 5254 5255 5256
		unsigned long copy_size = min_t(u64,
				  PAGE_CACHE_SIZE - pg_offset,
				  max_size - extent_offset);
		memset(kaddr + pg_offset, 0, copy_size);
5257
		kunmap_atomic(kaddr);
5258 5259 5260 5261 5262
	}
	kfree(tmp);
	return 0;
}

5263 5264
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
5265 5266
 * 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,
5267 5268 5269 5270
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
5271

5272
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
5273
				    size_t pg_offset, u64 start, u64 len,
5274 5275 5276 5277
				    int create)
{
	int ret;
	int err = 0;
5278
	u64 bytenr;
5279 5280
	u64 extent_start = 0;
	u64 extent_end = 0;
5281
	u64 objectid = btrfs_ino(inode);
5282
	u32 found_type;
5283
	struct btrfs_path *path = NULL;
5284 5285
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
5286 5287
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
5288 5289
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
5290
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
5291
	struct btrfs_trans_handle *trans = NULL;
5292
	int compress_type;
5293 5294

again:
5295
	read_lock(&em_tree->lock);
5296
	em = lookup_extent_mapping(em_tree, start, len);
5297 5298
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
5299
	read_unlock(&em_tree->lock);
5300

5301
	if (em) {
5302 5303 5304
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
5305 5306 5307
			free_extent_map(em);
		else
			goto out;
5308
	}
5309
	em = alloc_extent_map();
5310
	if (!em) {
5311 5312
		err = -ENOMEM;
		goto out;
5313
	}
5314
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5315
	em->start = EXTENT_MAP_HOLE;
5316
	em->orig_start = EXTENT_MAP_HOLE;
5317
	em->len = (u64)-1;
5318
	em->block_len = (u64)-1;
5319 5320 5321

	if (!path) {
		path = btrfs_alloc_path();
5322 5323 5324 5325 5326 5327 5328 5329 5330
		if (!path) {
			err = -ENOMEM;
			goto out;
		}
		/*
		 * Chances are we'll be called again, so go ahead and do
		 * readahead
		 */
		path->reada = 1;
5331 5332
	}

5333 5334
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

5346 5347
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
5348 5349
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
5350 5351 5352
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
5353 5354 5355 5356
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

5357 5358
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
5359
	compress_type = btrfs_file_extent_compression(leaf, item);
5360 5361
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5362
		extent_end = extent_start +
5363
		       btrfs_file_extent_num_bytes(leaf, item);
5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
		size_t size;
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_end = (extent_start + size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
	}

	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;
5378
			}
5379 5380 5381
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
5382
		}
5383 5384 5385 5386 5387 5388 5389
		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;
5390
		em->orig_start = start;
5391 5392 5393 5394
		em->len = found_key.offset - start;
		goto not_found_em;
	}

5395 5396
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5397 5398
		em->start = extent_start;
		em->len = extent_end - extent_start;
5399 5400
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
5401 5402
		em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
								      item);
5403 5404
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
5405
			em->block_start = EXTENT_MAP_HOLE;
5406 5407
			goto insert;
		}
5408
		if (compress_type != BTRFS_COMPRESS_NONE) {
5409
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5410
			em->compress_type = compress_type;
5411
			em->block_start = bytenr;
5412
			em->block_len = em->orig_block_len;
5413 5414 5415 5416
		} else {
			bytenr += btrfs_file_extent_offset(leaf, item);
			em->block_start = bytenr;
			em->block_len = em->len;
5417 5418
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
5419
		}
5420 5421
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
5422
		unsigned long ptr;
5423
		char *map;
5424 5425 5426
		size_t size;
		size_t extent_offset;
		size_t copy_size;
5427

5428
		em->block_start = EXTENT_MAP_INLINE;
5429
		if (!page || create) {
5430
			em->start = extent_start;
5431
			em->len = extent_end - extent_start;
5432 5433
			goto out;
		}
5434

5435 5436
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
5437
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
5438 5439
				size - extent_offset);
		em->start = extent_start + extent_offset;
5440 5441
		em->len = (copy_size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
5442
		em->orig_block_len = em->len;
5443
		em->orig_start = em->start;
5444
		if (compress_type) {
5445
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5446 5447
			em->compress_type = compress_type;
		}
5448
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
5449
		if (create == 0 && !PageUptodate(page)) {
5450 5451
			if (btrfs_file_extent_compression(leaf, item) !=
			    BTRFS_COMPRESS_NONE) {
5452 5453 5454
				ret = uncompress_inline(path, inode, page,
							pg_offset,
							extent_offset, item);
5455
				BUG_ON(ret); /* -ENOMEM */
5456 5457 5458 5459
			} else {
				map = kmap(page);
				read_extent_buffer(leaf, map + pg_offset, ptr,
						   copy_size);
5460 5461 5462 5463 5464
				if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
					memset(map + pg_offset + copy_size, 0,
					       PAGE_CACHE_SIZE - pg_offset -
					       copy_size);
				}
5465 5466
				kunmap(page);
			}
5467 5468
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
5469
			BUG();
5470 5471 5472 5473
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
C
Chris Mason 已提交
5474

5475
				btrfs_release_path(path);
5476
				trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
5477

5478 5479
				if (IS_ERR(trans))
					return ERR_CAST(trans);
5480 5481
				goto again;
			}
5482
			map = kmap(page);
5483
			write_extent_buffer(leaf, map + pg_offset, ptr,
5484
					    copy_size);
5485
			kunmap(page);
5486
			btrfs_mark_buffer_dirty(leaf);
5487
		}
5488
		set_extent_uptodate(io_tree, em->start,
5489
				    extent_map_end(em) - 1, NULL, GFP_NOFS);
5490 5491
		goto insert;
	} else {
J
Julia Lawall 已提交
5492
		WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
5493 5494 5495
	}
not_found:
	em->start = start;
5496
	em->orig_start = start;
5497
	em->len = len;
5498
not_found_em:
5499
	em->block_start = EXTENT_MAP_HOLE;
5500
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
5501
insert:
5502
	btrfs_release_path(path);
5503
	if (em->start > start || extent_map_end(em) <= start) {
5504 5505 5506 5507 5508
		printk(KERN_ERR "Btrfs: bad extent! em: [%llu %llu] passed "
		       "[%llu %llu]\n", (unsigned long long)em->start,
		       (unsigned long long)em->len,
		       (unsigned long long)start,
		       (unsigned long long)len);
5509 5510 5511
		err = -EIO;
		goto out;
	}
5512 5513

	err = 0;
5514
	write_lock(&em_tree->lock);
5515
	ret = add_extent_mapping(em_tree, em);
5516 5517 5518 5519
	/* 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
	 */
5520
	if (ret == -EEXIST) {
5521
		struct extent_map *existing;
5522 5523 5524

		ret = 0;

5525
		existing = lookup_extent_mapping(em_tree, start, len);
5526 5527 5528 5529 5530
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
5531 5532 5533 5534 5535
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
5536 5537
							   em, start,
							   root->sectorsize);
5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550
				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;
5551
			err = 0;
5552 5553
		}
	}
5554
	write_unlock(&em_tree->lock);
5555
out:
5556

5557 5558
	if (em)
		trace_btrfs_get_extent(root, em);
5559

5560 5561
	if (path)
		btrfs_free_path(path);
5562 5563
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
5564
		if (!err)
5565 5566 5567 5568 5569 5570
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
5571
	BUG_ON(!em); /* Error is always set */
5572 5573 5574
	return em;
}

5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636
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) {
		/*
		 * if our em maps to a hole, there might
		 * actually be delalloc bytes behind it
		 */
		if (em->block_start != EXTENT_MAP_HOLE)
			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;

5637
		em = alloc_extent_map();
5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696
		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;
		} 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;
}

5697 5698 5699 5700 5701
static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
						  u64 start, u64 len)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
5702
	struct extent_map *em;
5703 5704 5705 5706
	struct btrfs_key ins;
	u64 alloc_hint;
	int ret;

5707
	trans = btrfs_join_transaction(root);
5708 5709
	if (IS_ERR(trans))
		return ERR_CAST(trans);
5710 5711 5712 5713 5714

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

	alloc_hint = get_extent_allocation_hint(inode, start, len);
	ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
5715
				   alloc_hint, &ins, 1);
5716 5717 5718 5719 5720
	if (ret) {
		em = ERR_PTR(ret);
		goto out;
	}

5721 5722 5723 5724
	em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
			      ins.offset, ins.offset, 0);
	if (IS_ERR(em))
		goto out;
5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736

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

5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760
/*
 * returns 1 when the nocow is safe, < 1 on error, 0 if the
 * block must be cow'd
 */
static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
				      struct inode *inode, u64 offset, u64 len)
{
	struct btrfs_path *path;
	int ret;
	struct extent_buffer *leaf;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *fi;
	struct btrfs_key key;
	u64 disk_bytenr;
	u64 backref_offset;
	u64 extent_end;
	u64 num_bytes;
	int slot;
	int found_type;

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

5761
	ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777
				       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);
5778
	if (key.objectid != btrfs_ino(inode) ||
5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811
	    key.type != BTRFS_EXTENT_DATA_KEY) {
		/* not our file or wrong item type, must cow */
		goto out;
	}

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

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

	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
	if (extent_end < offset + len) {
		/* extent doesn't include our full range, must cow */
		goto out;
	}

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

	/*
	 * look for other files referencing this extent, if we
	 * find any we must cow
	 */
5812
	if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836
				  key.offset - backref_offset, disk_bytenr))
		goto out;

	/*
	 * adjust disk_bytenr and num_bytes to cover just the bytes
	 * in this extent we are about to write.  If there
	 * are any csums in that range we have to cow in order
	 * to keep the csums correct
	 */
	disk_bytenr += backref_offset;
	disk_bytenr += offset - key.offset;
	num_bytes = min(offset + len, extent_end) - offset;
	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
	 */
	ret = 1;
out:
	btrfs_free_path(path);
	return ret;
}

5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897
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;
}

5898 5899 5900
static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
					   u64 len, u64 orig_start,
					   u64 block_start, u64 block_len,
5901
					   u64 orig_block_len, int type)
5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918
{
	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;
	em->len = len;
	em->block_len = block_len;
	em->block_start = block_start;
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5919
	em->orig_block_len = orig_block_len;
5920
	em->generation = -1;
5921 5922
	set_bit(EXTENT_FLAG_PINNED, &em->flags);
	if (type == BTRFS_ORDERED_PREALLOC)
5923
		set_bit(EXTENT_FLAG_FILLING, &em->flags);
5924 5925 5926 5927 5928 5929

	do {
		btrfs_drop_extent_cache(inode, em->start,
				em->start + em->len - 1, 0);
		write_lock(&em_tree->lock);
		ret = add_extent_mapping(em_tree, em);
5930 5931 5932
		if (!ret)
			list_move(&em->list,
				  &em_tree->modified_extents);
5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944
		write_unlock(&em_tree->lock);
	} while (ret == -EEXIST);

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

	return em;
}


5945 5946 5947 5948 5949
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;
5950
	struct extent_state *cached_state = NULL;
5951
	u64 start = iblock << inode->i_blkbits;
5952
	u64 lockstart, lockend;
5953
	u64 len = bh_result->b_size;
5954
	struct btrfs_trans_handle *trans;
5955 5956 5957 5958 5959 5960 5961 5962
	int unlock_bits = EXTENT_LOCKED;
	int ret;

	if (create) {
		ret = btrfs_delalloc_reserve_space(inode, len);
		if (ret)
			return ret;
		unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY;
5963 5964
	} else {
		len = min_t(u64, len, root->sectorsize);
5965 5966
	}

5967 5968 5969
	lockstart = start;
	lockend = start + len - 1;

5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983
	/*
	 * 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;

	if (create) {
		ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
				     lockend, EXTENT_DELALLOC, NULL,
				     &cached_state, GFP_NOFS);
		if (ret)
			goto unlock_err;
	}
5984 5985

	em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
5986 5987 5988 5989
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007

	/*
	 * 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);
6008 6009
		ret = -ENOTBLK;
		goto unlock_err;
6010 6011 6012 6013 6014 6015
	}

	/* 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);
6016 6017
		ret = 0;
		goto unlock_err;
6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028
	}

	/*
	 * 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.
	 *
	 */
6029
	if (!create) {
6030 6031 6032
		len = min(len, em->len - (start - em->start));
		lockstart = start + len;
		goto unlock;
6033
	}
6034 6035 6036 6037 6038 6039

	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;
6040
		u64 block_start;
6041 6042 6043 6044 6045

		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
			type = BTRFS_ORDERED_PREALLOC;
		else
			type = BTRFS_ORDERED_NOCOW;
6046
		len = min(len, em->len - (start - em->start));
6047
		block_start = em->block_start + (start - em->start);
6048 6049 6050 6051 6052 6053

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

		if (can_nocow_odirect(trans, inode, start, len) == 1) {
6059
			u64 orig_start = em->orig_start;
6060
			u64 orig_block_len = em->orig_block_len;
6061 6062 6063 6064 6065

			if (type == BTRFS_ORDERED_PREALLOC) {
				free_extent_map(em);
				em = create_pinned_em(inode, start, len,
						       orig_start,
6066 6067
						       block_start, len,
						       orig_block_len, type);
6068 6069 6070 6071 6072 6073
				if (IS_ERR(em)) {
					btrfs_end_transaction(trans, root);
					goto unlock_err;
				}
			}

6074 6075 6076 6077 6078
			ret = btrfs_add_ordered_extent_dio(inode, start,
					   block_start, len, len, type);
			btrfs_end_transaction(trans, root);
			if (ret) {
				free_extent_map(em);
6079
				goto unlock_err;
6080 6081
			}
			goto unlock;
6082
		}
6083
		btrfs_end_transaction(trans, root);
6084
	}
6085 6086 6087 6088 6089 6090
must_cow:
	/*
	 * this will cow the extent, reset the len in case we changed
	 * it above
	 */
	len = bh_result->b_size;
6091 6092
	free_extent_map(em);
	em = btrfs_new_extent_direct(inode, start, len);
6093 6094 6095 6096
	if (IS_ERR(em)) {
		ret = PTR_ERR(em);
		goto unlock_err;
	}
6097 6098
	len = min(len, em->len - (start - em->start));
unlock:
6099 6100
	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
		inode->i_blkbits;
6101
	bh_result->b_size = len;
6102 6103
	bh_result->b_bdev = em->bdev;
	set_buffer_mapped(bh_result);
6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114
	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);
	}
6115

6116 6117 6118 6119 6120
	/*
	 * 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.
	 */
6121 6122 6123
	if (lockstart < lockend) {
		if (create && len < lockend - lockstart) {
			clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
6124 6125
					 lockstart + len - 1,
					 unlock_bits | EXTENT_DEFRAG, 1, 0,
6126 6127 6128 6129 6130 6131 6132
					 &cached_state, GFP_NOFS);
			/*
			 * Beside unlock, we also need to cleanup reserved space
			 * for the left range by attaching EXTENT_DO_ACCOUNTING.
			 */
			clear_extent_bit(&BTRFS_I(inode)->io_tree,
					 lockstart + len, lockend,
6133 6134
					 unlock_bits | EXTENT_DO_ACCOUNTING |
					 EXTENT_DEFRAG, 1, 0, NULL, GFP_NOFS);
6135 6136 6137 6138 6139 6140
		} else {
			clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
					 lockend, unlock_bits, 1, 0,
					 &cached_state, GFP_NOFS);
		}
	} else {
6141
		free_extent_state(cached_state);
6142
	}
6143

6144 6145 6146
	free_extent_map(em);

	return 0;
6147 6148 6149 6150 6151 6152 6153 6154

unlock_err:
	if (create)
		unlock_bits |= EXTENT_DO_ACCOUNTING;

	clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
			 unlock_bits, 1, 0, &cached_state, GFP_NOFS);
	return ret;
6155 6156 6157 6158 6159 6160 6161 6162
}

struct btrfs_dio_private {
	struct inode *inode;
	u64 logical_offset;
	u64 disk_bytenr;
	u64 bytes;
	void *private;
6163 6164 6165 6166 6167 6168 6169 6170

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

	/* IO errors */
	int errors;

	struct bio *orig_bio;
6171 6172 6173 6174
};

static void btrfs_endio_direct_read(struct bio *bio, int err)
{
6175
	struct btrfs_dio_private *dip = bio->bi_private;
6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187
	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;
	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;
6188
			u64 private = ~(u32)0;
6189 6190
			unsigned long flags;

6191 6192 6193
			if (get_state_private(&BTRFS_I(inode)->io_tree,
					      start, &private))
				goto failed;
6194
			local_irq_save(flags);
6195
			kaddr = kmap_atomic(page);
6196 6197 6198
			csum = btrfs_csum_data(root, kaddr + bvec->bv_offset,
					       csum, bvec->bv_len);
			btrfs_csum_final(csum, (char *)&csum);
6199
			kunmap_atomic(kaddr);
6200 6201 6202
			local_irq_restore(flags);

			flush_dcache_page(bvec->bv_page);
6203 6204
			if (csum != private) {
failed:
6205
				printk(KERN_ERR "btrfs csum failed ino %llu off"
6206
				      " %llu csum %u private %u\n",
6207 6208
				      (unsigned long long)btrfs_ino(inode),
				      (unsigned long long)start,
6209
				      csum, (unsigned)private);
6210 6211 6212 6213 6214 6215 6216 6217 6218
				err = -EIO;
			}
		}

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

	unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
6219
		      dip->logical_offset + dip->bytes - 1);
6220 6221 6222
	bio->bi_private = dip->private;

	kfree(dip);
6223 6224 6225 6226

	/* If we had a csum failure make sure to clear the uptodate flag */
	if (err)
		clear_bit(BIO_UPTODATE, &bio->bi_flags);
6227 6228 6229 6230 6231 6232 6233 6234 6235
	dio_end_io(bio, err);
}

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;
6236 6237
	u64 ordered_offset = dip->logical_offset;
	u64 ordered_bytes = dip->bytes;
6238 6239 6240 6241
	int ret;

	if (err)
		goto out_done;
6242 6243 6244
again:
	ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
						   &ordered_offset,
6245
						   ordered_bytes, !err);
6246
	if (!ret)
6247
		goto out_test;
6248

6249 6250 6251 6252
	ordered->work.func = finish_ordered_fn;
	ordered->work.flags = 0;
	btrfs_queue_worker(&root->fs_info->endio_write_workers,
			   &ordered->work);
6253 6254 6255 6256 6257 6258 6259 6260
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;
6261
		ordered = NULL;
6262 6263
		goto again;
	}
6264 6265 6266 6267
out_done:
	bio->bi_private = dip->private;

	kfree(dip);
6268 6269 6270 6271

	/* If we had an error make sure to clear the uptodate flag */
	if (err)
		clear_bit(BIO_UPTODATE, &bio->bi_flags);
6272 6273 6274
	dio_end_io(bio, err);
}

6275 6276 6277 6278 6279 6280 6281
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);
6282
	BUG_ON(ret); /* -ENOMEM */
6283 6284 6285
	return 0;
}

6286 6287 6288 6289 6290
static void btrfs_end_dio_bio(struct bio *bio, int err)
{
	struct btrfs_dio_private *dip = bio->bi_private;

	if (err) {
6291
		printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
6292
		      "sector %#Lx len %u err no %d\n",
6293
		      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
6294
		      (unsigned long long)bio->bi_sector, bio->bi_size, err);
6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326
		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;

	if (dip->errors)
		bio_io_error(dip->orig_bio);
	else {
		set_bit(BIO_UPTODATE, &dip->orig_bio->bi_flags);
		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,
6327
					 int async_submit)
6328 6329 6330 6331 6332
{
	int write = rw & REQ_WRITE;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

6333 6334 6335
	if (async_submit)
		async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);

6336
	bio_get(bio);
6337 6338 6339 6340 6341 6342

	if (!write) {
		ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
		if (ret)
			goto err;
	}
6343

6344 6345 6346 6347
	if (skip_sum)
		goto map;

	if (write && async_submit) {
6348 6349 6350 6351 6352 6353
		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;
6354 6355 6356 6357 6358 6359 6360 6361
	} 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;
6362
	} else if (!skip_sum) {
6363
		ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
6364 6365 6366
		if (ret)
			goto err;
	}
6367

6368 6369
map:
	ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388
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;
6389
	int async_submit = 0;
6390 6391

	map_length = orig_bio->bi_size;
6392
	ret = btrfs_map_block(root->fs_info, READ, start_sector << 9,
6393 6394
			      &map_length, NULL, 0);
	if (ret) {
6395
		bio_put(orig_bio);
6396 6397 6398
		return -EIO;
	}

6399 6400 6401 6402 6403
	if (map_length >= orig_bio->bi_size) {
		bio = orig_bio;
		goto submit;
	}

6404
	async_submit = 1;
6405 6406 6407 6408 6409 6410 6411
	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);

6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424
	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,
6425
						     async_submit);
6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445
			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;
6446 6447
			ret = btrfs_map_block(root->fs_info, READ,
					      start_sector << 9,
6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459
					      &map_length, NULL, 0);
			if (ret) {
				bio_put(bio);
				goto out_err;
			}
		} else {
			submit_len += bvec->bv_len;
			nr_pages ++;
			bvec++;
		}
	}

6460
submit:
6461
	ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
6462
				     async_submit);
6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480
	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;
}

6481 6482 6483 6484 6485 6486 6487
static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
				loff_t file_offset)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_dio_private *dip;
	struct bio_vec *bvec = bio->bi_io_vec;
	int skip_sum;
6488
	int write = rw & REQ_WRITE;
6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508
	int ret = 0;

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

	dip = kmalloc(sizeof(*dip), GFP_NOFS);
	if (!dip) {
		ret = -ENOMEM;
		goto free_ordered;
	}

	dip->private = bio->bi_private;
	dip->inode = inode;
	dip->logical_offset = file_offset;

	dip->bytes = 0;
	do {
		dip->bytes += bvec->bv_len;
		bvec++;
	} while (bvec <= (bio->bi_io_vec + bio->bi_vcnt - 1));

6509
	dip->disk_bytenr = (u64)bio->bi_sector << 9;
6510
	bio->bi_private = dip;
6511 6512 6513
	dip->errors = 0;
	dip->orig_bio = bio;
	atomic_set(&dip->pending_bios, 0);
6514 6515 6516 6517 6518 6519

	if (write)
		bio->bi_end_io = btrfs_endio_direct_write;
	else
		bio->bi_end_io = btrfs_endio_direct_read;

6520 6521
	ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
	if (!ret)
6522
		return;
6523 6524 6525 6526 6527 6528 6529
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;
6530
		ordered = btrfs_lookup_ordered_extent(inode, file_offset);
6531 6532 6533 6534 6535 6536 6537 6538 6539 6540
		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);
	}
	bio_endio(bio, ret);
}

C
Chris Mason 已提交
6541 6542 6543 6544 6545
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;
6546
	int i;
C
Chris Mason 已提交
6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560
	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;
6561
		if ((addr & blocksize_mask) || (size & blocksize_mask))
C
Chris Mason 已提交
6562
			goto out;
6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576

		/* 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 已提交
6577 6578 6579 6580 6581
	}
	retval = 0;
out:
	return retval;
}
6582

6583 6584 6585 6586
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
6587 6588 6589
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;

C
Chris Mason 已提交
6590
	if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
6591
			    offset, nr_segs))
C
Chris Mason 已提交
6592
		return 0;
6593

6594
	return __blockdev_direct_IO(rw, iocb, inode,
C
Chris Mason 已提交
6595 6596 6597
		   BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
		   iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
		   btrfs_submit_direct, 0);
6598 6599
}

6600 6601
#define BTRFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC)

Y
Yehuda Sadeh 已提交
6602 6603 6604
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
6605 6606 6607 6608 6609 6610
	int	ret;

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

6611
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
Y
Yehuda Sadeh 已提交
6612 6613
}

6614
int btrfs_readpage(struct file *file, struct page *page)
6615
{
6616 6617
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
6618
	return extent_read_full_page(tree, page, btrfs_get_extent, 0);
6619
}
6620

6621
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
6622
{
6623
	struct extent_io_tree *tree;
6624 6625 6626 6627 6628 6629 6630


	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
6631
	tree = &BTRFS_I(page->mapping->host)->io_tree;
6632
	return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
6633 6634
}

6635 6636
int btrfs_writepages(struct address_space *mapping,
		     struct writeback_control *wbc)
6637
{
6638
	struct extent_io_tree *tree;
6639

6640
	tree = &BTRFS_I(mapping->host)->io_tree;
6641 6642 6643
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

6644 6645 6646 6647
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
6648 6649
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
6650 6651 6652
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
6653
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
6654
{
6655 6656
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
6657
	int ret;
6658

6659 6660
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
6661
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
6662 6663 6664 6665
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
6666
	}
6667
	return ret;
C
Chris Mason 已提交
6668 6669
}

6670 6671
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
6672 6673
	if (PageWriteback(page) || PageDirty(page))
		return 0;
6674
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
6675 6676
}

6677
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
6678
{
6679
	struct inode *inode = page->mapping->host;
6680
	struct extent_io_tree *tree;
6681
	struct btrfs_ordered_extent *ordered;
6682
	struct extent_state *cached_state = NULL;
6683 6684
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
6685

6686 6687 6688 6689 6690 6691 6692
	/*
	 * 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
	 */
6693
	wait_on_page_writeback(page);
6694

6695
	tree = &BTRFS_I(inode)->io_tree;
6696 6697 6698 6699
	if (offset) {
		btrfs_releasepage(page, GFP_NOFS);
		return;
	}
6700
	lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
6701
	ordered = btrfs_lookup_ordered_extent(inode,
6702 6703
					   page_offset(page));
	if (ordered) {
6704 6705 6706 6707
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
6708 6709
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
6710 6711
				 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
				 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
6712 6713 6714 6715
		/*
		 * whoever cleared the private bit is responsible
		 * for the finish_ordered_io
		 */
6716 6717 6718 6719
		if (TestClearPagePrivate2(page) &&
		    btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
						   PAGE_CACHE_SIZE, 1)) {
			btrfs_finish_ordered_io(ordered);
6720
		}
6721
		btrfs_put_ordered_extent(ordered);
6722
		cached_state = NULL;
6723
		lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
6724 6725
	}
	clear_extent_bit(tree, page_start, page_end,
6726
		 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
6727 6728
		 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
		 &cached_state, GFP_NOFS);
6729 6730
	__btrfs_releasepage(page, GFP_NOFS);

C
Chris Mason 已提交
6731
	ClearPageChecked(page);
6732 6733 6734 6735 6736
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
6737 6738
}

6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753
/*
 * 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.
 */
6754
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
6755
{
6756
	struct page *page = vmf->page;
6757
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
6758
	struct btrfs_root *root = BTRFS_I(inode)->root;
6759 6760
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
6761
	struct extent_state *cached_state = NULL;
6762 6763
	char *kaddr;
	unsigned long zero_start;
6764
	loff_t size;
6765
	int ret;
6766
	int reserved = 0;
6767
	u64 page_start;
6768
	u64 page_end;
6769

6770
	sb_start_pagefault(inode->i_sb);
6771
	ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
6772
	if (!ret) {
6773
		ret = file_update_time(vma->vm_file);
6774 6775
		reserved = 1;
	}
6776 6777 6778 6779 6780
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
6781 6782 6783
		if (reserved)
			goto out;
		goto out_noreserve;
6784
	}
6785

6786
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
6787
again:
6788 6789
	lock_page(page);
	size = i_size_read(inode);
6790 6791
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
6792

6793
	if ((page->mapping != inode->i_mapping) ||
6794
	    (page_start >= size)) {
6795 6796 6797
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
6798 6799
	wait_on_page_writeback(page);

6800
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
6801 6802
	set_page_extent_mapped(page);

6803 6804 6805 6806
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
6807 6808
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
6809 6810
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
6811
		unlock_page(page);
6812
		btrfs_start_ordered_extent(inode, ordered, 1);
6813 6814 6815 6816
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

6817 6818 6819 6820 6821 6822 6823
	/*
	 * 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.
	 */
6824
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
6825 6826
			  EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
6827
			  0, 0, &cached_state, GFP_NOFS);
6828

6829 6830
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
6831
	if (ret) {
6832 6833
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
6834 6835 6836
		ret = VM_FAULT_SIGBUS;
		goto out_unlock;
	}
6837
	ret = 0;
6838 6839

	/* page is wholly or partially inside EOF */
6840
	if (page_start + PAGE_CACHE_SIZE > size)
6841
		zero_start = size & ~PAGE_CACHE_MASK;
6842
	else
6843
		zero_start = PAGE_CACHE_SIZE;
6844

6845 6846 6847 6848 6849 6850
	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);
	}
6851
	ClearPageChecked(page);
6852
	set_page_dirty(page);
6853
	SetPageUptodate(page);
6854

6855 6856
	BTRFS_I(inode)->last_trans = root->fs_info->generation;
	BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
6857
	BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
6858

6859
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
6860 6861

out_unlock:
6862 6863
	if (!ret) {
		sb_end_pagefault(inode->i_sb);
6864
		return VM_FAULT_LOCKED;
6865
	}
6866
	unlock_page(page);
6867
out:
6868
	btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
6869
out_noreserve:
6870
	sb_end_pagefault(inode->i_sb);
6871 6872 6873
	return ret;
}

6874
static int btrfs_truncate(struct inode *inode)
C
Chris Mason 已提交
6875 6876
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
6877
	struct btrfs_block_rsv *rsv;
C
Chris Mason 已提交
6878
	int ret;
6879
	int err = 0;
C
Chris Mason 已提交
6880
	struct btrfs_trans_handle *trans;
6881
	u64 mask = root->sectorsize - 1;
6882
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
6883

J
Josef Bacik 已提交
6884
	ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
6885
	if (ret)
6886
		return ret;
6887

C
Chris Mason 已提交
6888
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
6889
	btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
C
Chris Mason 已提交
6890

6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926
	/*
	 * 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.
	 */
6927
	rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
6928 6929
	if (!rsv)
		return -ENOMEM;
6930
	rsv->size = min_size;
6931
	rsv->failfast = 1;
6932

6933
	/*
6934
	 * 1 for the truncate slack space
6935 6936 6937 6938
	 * 1 for the orphan item we're going to add
	 * 1 for the orphan item deletion
	 * 1 for updating the inode.
	 */
6939 6940 6941 6942 6943
	trans = btrfs_start_transaction(root, 4);
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out;
	}
6944

6945 6946 6947
	/* Migrate the slack space for the truncate to our reserve */
	ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
				      min_size);
6948
	BUG_ON(ret);
6949 6950 6951 6952

	ret = btrfs_orphan_add(trans, inode);
	if (ret) {
		btrfs_end_transaction(trans, root);
6953
		goto out;
6954 6955
	}

6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972
	/*
	 * 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.
	 */
6973 6974
	if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
					   &BTRFS_I(inode)->runtime_flags))
6975 6976
		btrfs_add_ordered_operation(trans, root, inode);

J
Josef Bacik 已提交
6977 6978 6979 6980 6981 6982 6983 6984
	/*
	 * 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);
6985
	trans->block_rsv = rsv;
6986

6987 6988 6989 6990
	while (1) {
		ret = btrfs_truncate_inode_items(trans, root, inode,
						 inode->i_size,
						 BTRFS_EXTENT_DATA_KEY);
6991
		if (ret != -ENOSPC) {
6992
			err = ret;
6993
			break;
6994
		}
C
Chris Mason 已提交
6995

6996
		trans->block_rsv = &root->fs_info->trans_block_rsv;
6997
		ret = btrfs_update_inode(trans, root, inode);
6998 6999 7000 7001
		if (ret) {
			err = ret;
			break;
		}
7002

7003
		btrfs_end_transaction(trans, root);
7004
		btrfs_btree_balance_dirty(root);
7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016

		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;
7017 7018 7019
	}

	if (ret == 0 && inode->i_nlink > 0) {
7020
		trans->block_rsv = root->orphan_block_rsv;
7021
		ret = btrfs_orphan_del(trans, inode);
7022 7023
		if (ret)
			err = ret;
7024 7025 7026 7027 7028 7029
	} else if (ret && inode->i_nlink > 0) {
		/*
		 * Failed to do the truncate, remove us from the in memory
		 * orphan list.
		 */
		ret = btrfs_orphan_del(NULL, inode);
7030 7031
	}

7032 7033 7034 7035 7036
	if (trans) {
		trans->block_rsv = &root->fs_info->trans_block_rsv;
		ret = btrfs_update_inode(trans, root, inode);
		if (ret && !err)
			err = ret;
7037

7038
		ret = btrfs_end_transaction(trans, root);
7039
		btrfs_btree_balance_dirty(root);
7040
	}
7041 7042 7043 7044

out:
	btrfs_free_block_rsv(root, rsv);

7045 7046
	if (ret && !err)
		err = ret;
7047

7048
	return err;
C
Chris Mason 已提交
7049 7050
}

7051 7052 7053
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
7054
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
7055
			     struct btrfs_root *new_root, u64 new_dirid)
C
Chris Mason 已提交
7056 7057
{
	struct inode *inode;
7058
	int err;
7059
	u64 index = 0;
C
Chris Mason 已提交
7060

7061 7062 7063 7064
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
				new_dirid, new_dirid,
				S_IFDIR | (~current_umask() & S_IRWXUGO),
				&index);
7065
	if (IS_ERR(inode))
7066
		return PTR_ERR(inode);
C
Chris Mason 已提交
7067 7068 7069
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

7070
	set_nlink(inode, 1);
7071
	btrfs_i_size_write(inode, 0);
7072

7073
	err = btrfs_update_inode(trans, new_root, inode);
7074

7075
	iput(inode);
7076
	return err;
C
Chris Mason 已提交
7077 7078 7079 7080 7081
}

struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;
Y
Yan, Zheng 已提交
7082
	struct inode *inode;
C
Chris Mason 已提交
7083 7084 7085 7086

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
Y
Yan, Zheng 已提交
7087 7088 7089

	ei->root = NULL;
	ei->generation = 0;
7090
	ei->last_trans = 0;
7091
	ei->last_sub_trans = 0;
7092
	ei->logged_trans = 0;
Y
Yan, Zheng 已提交
7093 7094 7095
	ei->delalloc_bytes = 0;
	ei->disk_i_size = 0;
	ei->flags = 0;
7096
	ei->csum_bytes = 0;
Y
Yan, Zheng 已提交
7097 7098
	ei->index_cnt = (u64)-1;
	ei->last_unlink_trans = 0;
7099
	ei->last_log_commit = 0;
Y
Yan, Zheng 已提交
7100

7101 7102 7103
	spin_lock_init(&ei->lock);
	ei->outstanding_extents = 0;
	ei->reserved_extents = 0;
Y
Yan, Zheng 已提交
7104

7105
	ei->runtime_flags = 0;
7106
	ei->force_compress = BTRFS_COMPRESS_NONE;
Y
Yan, Zheng 已提交
7107

7108 7109
	ei->delayed_node = NULL;

Y
Yan, Zheng 已提交
7110
	inode = &ei->vfs_inode;
7111
	extent_map_tree_init(&ei->extent_tree);
7112 7113
	extent_io_tree_init(&ei->io_tree, &inode->i_data);
	extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
7114 7115
	ei->io_tree.track_uptodate = 1;
	ei->io_failure_tree.track_uptodate = 1;
7116
	atomic_set(&ei->sync_writers, 0);
Y
Yan, Zheng 已提交
7117
	mutex_init(&ei->log_mutex);
7118
	mutex_init(&ei->delalloc_mutex);
7119
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
Y
Yan, Zheng 已提交
7120
	INIT_LIST_HEAD(&ei->delalloc_inodes);
7121
	INIT_LIST_HEAD(&ei->ordered_operations);
Y
Yan, Zheng 已提交
7122 7123 7124
	RB_CLEAR_NODE(&ei->rb_node);

	return inode;
C
Chris Mason 已提交
7125 7126
}

N
Nick Piggin 已提交
7127 7128 7129 7130 7131 7132
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 已提交
7133 7134
void btrfs_destroy_inode(struct inode *inode)
{
7135
	struct btrfs_ordered_extent *ordered;
7136 7137
	struct btrfs_root *root = BTRFS_I(inode)->root;

7138
	WARN_ON(!hlist_empty(&inode->i_dentry));
C
Chris Mason 已提交
7139
	WARN_ON(inode->i_data.nrpages);
7140 7141
	WARN_ON(BTRFS_I(inode)->outstanding_extents);
	WARN_ON(BTRFS_I(inode)->reserved_extents);
7142 7143
	WARN_ON(BTRFS_I(inode)->delalloc_bytes);
	WARN_ON(BTRFS_I(inode)->csum_bytes);
C
Chris Mason 已提交
7144

7145 7146 7147 7148 7149 7150 7151 7152
	/*
	 * 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;

7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163
	/*
	 * Make sure we're properly removed from the ordered operation
	 * lists.
	 */
	smp_mb();
	if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
		spin_lock(&root->fs_info->ordered_extent_lock);
		list_del_init(&BTRFS_I(inode)->ordered_operations);
		spin_unlock(&root->fs_info->ordered_extent_lock);
	}

7164 7165
	if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
		     &BTRFS_I(inode)->runtime_flags)) {
7166 7167
		printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
		       (unsigned long long)btrfs_ino(inode));
7168
		atomic_dec(&root->orphan_inodes);
7169 7170
	}

7171
	while (1) {
7172 7173 7174 7175
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
7176 7177 7178 7179
			printk(KERN_ERR "btrfs found ordered "
			       "extent %llu %llu on inode cleanup\n",
			       (unsigned long long)ordered->file_offset,
			       (unsigned long long)ordered->len);
7180 7181 7182 7183 7184
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
7185
	inode_tree_del(inode);
7186
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
7187
free:
7188
	btrfs_remove_delayed_node(inode);
N
Nick Piggin 已提交
7189
	call_rcu(&inode->i_rcu, btrfs_i_callback);
C
Chris Mason 已提交
7190 7191
}

7192
int btrfs_drop_inode(struct inode *inode)
7193 7194
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
7195

7196
	if (btrfs_root_refs(&root->root_item) == 0 &&
7197
	    !btrfs_is_free_space_inode(inode))
7198
		return 1;
7199
	else
7200
		return generic_drop_inode(inode);
7201 7202
}

7203
static void init_once(void *foo)
C
Chris Mason 已提交
7204 7205 7206 7207 7208 7209 7210 7211
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
7212 7213 7214 7215 7216
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
C
Chris Mason 已提交
7217 7218 7219 7220 7221 7222 7223 7224
	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);
7225 7226
	if (btrfs_free_space_cachep)
		kmem_cache_destroy(btrfs_free_space_cachep);
7227 7228
	if (btrfs_delalloc_work_cachep)
		kmem_cache_destroy(btrfs_delalloc_work_cachep);
C
Chris Mason 已提交
7229 7230 7231 7232
}

int btrfs_init_cachep(void)
{
7233
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
7234 7235
			sizeof(struct btrfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
C
Chris Mason 已提交
7236 7237
	if (!btrfs_inode_cachep)
		goto fail;
7238

7239
	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
7240 7241
			sizeof(struct btrfs_trans_handle), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7242 7243
	if (!btrfs_trans_handle_cachep)
		goto fail;
7244

7245
	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
7246 7247
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7248 7249
	if (!btrfs_transaction_cachep)
		goto fail;
7250

7251
	btrfs_path_cachep = kmem_cache_create("btrfs_path",
7252 7253
			sizeof(struct btrfs_path), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
7254 7255
	if (!btrfs_path_cachep)
		goto fail;
7256

7257
	btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
7258 7259 7260 7261 7262
			sizeof(struct btrfs_free_space), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
	if (!btrfs_free_space_cachep)
		goto fail;

7263 7264 7265 7266 7267 7268 7269
	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 已提交
7270 7271 7272 7273 7274 7275 7276 7277 7278 7279
	return 0;
fail:
	btrfs_destroy_cachep();
	return -ENOMEM;
}

static int btrfs_getattr(struct vfsmount *mnt,
			 struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
7280 7281
	u32 blocksize = inode->i_sb->s_blocksize;

C
Chris Mason 已提交
7282
	generic_fillattr(inode, stat);
7283
	stat->dev = BTRFS_I(inode)->root->anon_dev;
7284
	stat->blksize = PAGE_CACHE_SIZE;
7285 7286
	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
		ALIGN(BTRFS_I(inode)->delalloc_bytes, blocksize)) >> 9;
C
Chris Mason 已提交
7287 7288 7289
	return 0;
}

7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303
/*
 * If a file is moved, it will inherit the cow and compression flags of the new
 * directory.
 */
static void fixup_inode_flags(struct inode *dir, struct inode *inode)
{
	struct btrfs_inode *b_dir = BTRFS_I(dir);
	struct btrfs_inode *b_inode = BTRFS_I(inode);

	if (b_dir->flags & BTRFS_INODE_NODATACOW)
		b_inode->flags |= BTRFS_INODE_NODATACOW;
	else
		b_inode->flags &= ~BTRFS_INODE_NODATACOW;

7304
	if (b_dir->flags & BTRFS_INODE_COMPRESS) {
7305
		b_inode->flags |= BTRFS_INODE_COMPRESS;
7306 7307 7308 7309 7310
		b_inode->flags &= ~BTRFS_INODE_NOCOMPRESS;
	} else {
		b_inode->flags &= ~(BTRFS_INODE_COMPRESS |
				    BTRFS_INODE_NOCOMPRESS);
	}
7311 7312
}

7313 7314
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
7315 7316 7317
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
7318
	struct btrfs_root *dest = BTRFS_I(new_dir)->root;
C
Chris Mason 已提交
7319 7320 7321
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
7322
	u64 index = 0;
7323
	u64 root_objectid;
C
Chris Mason 已提交
7324
	int ret;
7325
	u64 old_ino = btrfs_ino(old_inode);
C
Chris Mason 已提交
7326

7327
	if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
7328 7329
		return -EPERM;

7330
	/* we only allow rename subvolume link between subvolumes */
7331
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
7332 7333
		return -EXDEV;

7334 7335
	if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
	    (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
C
Chris Mason 已提交
7336
		return -ENOTEMPTY;
7337

7338 7339 7340
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
		return -ENOTEMPTY;
7341 7342 7343 7344 7345
	/*
	 * 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
	 */
7346
	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
7347 7348 7349
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

7350
	/* close the racy window with snapshot create/destroy ioctl */
7351
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
7352
		down_read(&root->fs_info->subvol_sem);
7353 7354 7355 7356 7357 7358 7359 7360 7361
	/*
	 * 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.
	 */
	trans = btrfs_start_transaction(root, 20);
7362 7363 7364 7365
	if (IS_ERR(trans)) {
                ret = PTR_ERR(trans);
                goto out_notrans;
        }
7366

7367 7368
	if (dest != root)
		btrfs_record_root_in_trans(trans, dest);
7369

7370 7371 7372
	ret = btrfs_set_inode_index(new_dir, &index);
	if (ret)
		goto out_fail;
7373

7374
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
7375 7376 7377
		/* force full log commit if subvolume involved. */
		root->fs_info->last_trans_log_full_commit = trans->transid;
	} else {
7378 7379 7380
		ret = btrfs_insert_inode_ref(trans, dest,
					     new_dentry->d_name.name,
					     new_dentry->d_name.len,
7381 7382
					     old_ino,
					     btrfs_ino(new_dir), index);
7383 7384
		if (ret)
			goto out_fail;
7385 7386 7387 7388 7389 7390 7391 7392 7393
		/*
		 * 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);
	}
7394 7395 7396 7397
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
7398
	if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
7399 7400
		btrfs_add_ordered_operation(trans, root, old_inode);

7401 7402 7403
	inode_inc_iversion(old_dir);
	inode_inc_iversion(new_dir);
	inode_inc_iversion(old_inode);
C
Chris Mason 已提交
7404 7405 7406
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
7407

7408 7409 7410
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

7411
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
7412 7413 7414 7415 7416
		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 {
7417 7418 7419 7420 7421 7422
		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);
7423
	}
7424 7425 7426 7427
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
7428 7429

	if (new_inode) {
7430
		inode_inc_iversion(new_inode);
C
Chris Mason 已提交
7431
		new_inode->i_ctime = CURRENT_TIME;
7432
		if (unlikely(btrfs_ino(new_inode) ==
7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445
			     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);
		}
7446
		if (!ret && new_inode->i_nlink == 0) {
7447
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
7448
			BUG_ON(ret);
7449
		}
7450 7451 7452 7453
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			goto out_fail;
		}
C
Chris Mason 已提交
7454
	}
7455

7456 7457
	fixup_inode_flags(new_dir, old_inode);

7458 7459
	ret = btrfs_add_link(trans, new_dir, old_inode,
			     new_dentry->d_name.name,
7460
			     new_dentry->d_name.len, 0, index);
7461 7462 7463 7464
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out_fail;
	}
C
Chris Mason 已提交
7465

7466
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
7467
		struct dentry *parent = new_dentry->d_parent;
7468
		btrfs_log_new_name(trans, old_inode, old_dir, parent);
7469 7470
		btrfs_end_log_trans(root);
	}
C
Chris Mason 已提交
7471
out_fail:
7472
	btrfs_end_transaction(trans, root);
7473
out_notrans:
7474
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
7475
		up_read(&root->fs_info->subvol_sem);
7476

C
Chris Mason 已提交
7477 7478 7479
	return ret;
}

7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522
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);
}

7523 7524 7525 7526
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
Y
Yan, Zheng 已提交
7527
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7528 7529 7530
{
	struct list_head *head = &root->fs_info->delalloc_inodes;
	struct btrfs_inode *binode;
7531
	struct inode *inode;
7532 7533 7534
	struct btrfs_delalloc_work *work, *next;
	struct list_head works;
	int ret = 0;
7535

7536 7537 7538
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

7539 7540
	INIT_LIST_HEAD(&works);

7541
	spin_lock(&root->fs_info->delalloc_lock);
7542
	while (!list_empty(head)) {
7543 7544
		binode = list_entry(head->next, struct btrfs_inode,
				    delalloc_inodes);
7545 7546 7547
		inode = igrab(&binode->vfs_inode);
		if (!inode)
			list_del_init(&binode->delalloc_inodes);
7548
		spin_unlock(&root->fs_info->delalloc_lock);
7549
		if (inode) {
7550 7551 7552 7553 7554 7555 7556 7557
			work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
			if (!work) {
				ret = -ENOMEM;
				goto out;
			}
			list_add_tail(&work->list, &works);
			btrfs_queue_worker(&root->fs_info->flush_workers,
					   &work->work);
7558 7559
		}
		cond_resched();
7560
		spin_lock(&root->fs_info->delalloc_lock);
7561
	}
7562
	spin_unlock(&root->fs_info->delalloc_lock);
7563 7564 7565 7566 7567 7568

	/* the filemap_flush will queue IO into the worker threads, but
	 * 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);
7569
	while (atomic_read(&root->fs_info->nr_async_submits) ||
7570
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
7571
		wait_event(root->fs_info->async_submit_wait,
7572 7573
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
7574 7575
	}
	atomic_dec(&root->fs_info->async_submit_draining);
7576 7577 7578 7579 7580 7581
out:
	list_for_each_entry_safe(work, next, &works, list) {
		list_del_init(&work->list);
		btrfs_wait_and_free_delalloc_work(work);
	}
	return ret;
7582 7583
}

C
Chris Mason 已提交
7584 7585 7586 7587 7588 7589 7590
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;
7591
	struct inode *inode = NULL;
C
Chris Mason 已提交
7592 7593 7594
	int err;
	int drop_inode = 0;
	u64 objectid;
7595
	u64 index = 0 ;
C
Chris Mason 已提交
7596 7597
	int name_len;
	int datasize;
7598
	unsigned long ptr;
C
Chris Mason 已提交
7599
	struct btrfs_file_extent_item *ei;
7600
	struct extent_buffer *leaf;
C
Chris Mason 已提交
7601 7602 7603 7604

	name_len = strlen(symname) + 1;
	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
		return -ENAMETOOLONG;
7605

7606 7607 7608 7609 7610
	/*
	 * 2 items for inode item and ref
	 * 2 items for dir items
	 * 1 item for xattr if selinux is on
	 */
7611 7612 7613
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
7614

7615 7616 7617 7618
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

7619
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
7620
				dentry->d_name.len, btrfs_ino(dir), objectid,
7621
				S_IFLNK|S_IRWXUGO, &index);
7622 7623
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
7624
		goto out_unlock;
7625
	}
C
Chris Mason 已提交
7626

7627
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
7628 7629 7630 7631 7632
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

7633 7634 7635 7636 7637 7638 7639 7640 7641
	/*
	* 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;

7642
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
7643 7644 7645 7646
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
7647
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7648
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
7649 7650 7651 7652 7653
	}
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
7654 7655 7656 7657 7658
	if (!path) {
		err = -ENOMEM;
		drop_inode = 1;
		goto out_unlock;
	}
7659
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
7660 7661 7662 7663 7664
	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);
7665 7666
	if (err) {
		drop_inode = 1;
7667
		btrfs_free_path(path);
7668 7669
		goto out_unlock;
	}
7670 7671 7672 7673 7674
	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 已提交
7675
				   BTRFS_FILE_EXTENT_INLINE);
7676 7677 7678 7679 7680
	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 已提交
7681
	ptr = btrfs_file_extent_inline_start(ei);
7682 7683
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
7684
	btrfs_free_path(path);
7685

C
Chris Mason 已提交
7686 7687
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
7688
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7689
	inode_set_bytes(inode, name_len);
7690
	btrfs_i_size_write(inode, name_len - 1);
7691 7692 7693
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
7694 7695

out_unlock:
7696 7697
	if (!err)
		d_instantiate(dentry, inode);
7698
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
7699 7700 7701 7702
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
7703
	btrfs_btree_balance_dirty(root);
C
Chris Mason 已提交
7704 7705
	return err;
}
7706

7707 7708 7709 7710
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)
7711
{
J
Josef Bacik 已提交
7712 7713
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
7714 7715 7716
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 cur_offset = start;
7717
	u64 i_size;
7718
	int ret = 0;
7719
	bool own_trans = true;
7720

7721 7722
	if (trans)
		own_trans = false;
7723
	while (num_bytes > 0) {
7724 7725 7726 7727 7728 7729
		if (own_trans) {
			trans = btrfs_start_transaction(root, 3);
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				break;
			}
7730 7731
		}

7732
		ret = btrfs_reserve_extent(trans, root, num_bytes, min_size,
7733
					   0, *alloc_hint, &ins, 1);
7734
		if (ret) {
7735 7736
			if (own_trans)
				btrfs_end_transaction(trans, root);
7737
			break;
7738
		}
7739

7740 7741 7742
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
7743
						  ins.offset, 0, 0, 0,
7744
						  BTRFS_FILE_EXTENT_PREALLOC);
7745 7746 7747 7748 7749 7750
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
7751 7752
		btrfs_drop_extent_cache(inode, cur_offset,
					cur_offset + ins.offset -1, 0);
7753

J
Josef Bacik 已提交
7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765
		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;
7766
		em->orig_block_len = ins.offset;
J
Josef Bacik 已提交
7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785
		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);
			ret = add_extent_mapping(em_tree, em);
			if (!ret)
				list_move(&em->list,
					  &em_tree->modified_extents);
			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:
7786 7787
		num_bytes -= ins.offset;
		cur_offset += ins.offset;
7788
		*alloc_hint = ins.objectid + ins.offset;
7789

7790
		inode_inc_iversion(inode);
7791
		inode->i_ctime = CURRENT_TIME;
7792
		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
7793
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
7794 7795
		    (actual_len > inode->i_size) &&
		    (cur_offset > inode->i_size)) {
7796
			if (cur_offset > actual_len)
7797
				i_size = actual_len;
7798
			else
7799 7800 7801
				i_size = cur_offset;
			i_size_write(inode, i_size);
			btrfs_ordered_update_i_size(inode, i_size, NULL);
7802 7803
		}

7804
		ret = btrfs_update_inode(trans, root, inode);
7805 7806 7807 7808 7809 7810 7811

		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			if (own_trans)
				btrfs_end_transaction(trans, root);
			break;
		}
7812

7813 7814
		if (own_trans)
			btrfs_end_transaction(trans, root);
7815
	}
7816 7817 7818
	return ret;
}

7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836
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);
}

7837 7838 7839 7840 7841
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

7842
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
7843
{
7844
	struct btrfs_root *root = BTRFS_I(inode)->root;
7845
	umode_t mode = inode->i_mode;
7846

7847 7848 7849 7850 7851 7852 7853
	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;
	}
7854
	return generic_permission(inode, mask);
Y
Yan 已提交
7855
}
C
Chris Mason 已提交
7856

7857
static const struct inode_operations btrfs_dir_inode_operations = {
7858
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
7859 7860 7861 7862 7863 7864 7865 7866 7867
	.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 已提交
7868
	.mknod		= btrfs_mknod,
7869 7870
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7871
	.listxattr	= btrfs_listxattr,
7872
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
7873
	.permission	= btrfs_permission,
7874
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7875
};
7876
static const struct inode_operations btrfs_dir_ro_inode_operations = {
C
Chris Mason 已提交
7877
	.lookup		= btrfs_lookup,
Y
Yan 已提交
7878
	.permission	= btrfs_permission,
7879
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7880
};
7881

7882
static const struct file_operations btrfs_dir_file_operations = {
C
Chris Mason 已提交
7883 7884
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
7885
	.readdir	= btrfs_real_readdir,
7886
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
7887
#ifdef CONFIG_COMPAT
7888
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
7889
#endif
S
Sage Weil 已提交
7890
	.release        = btrfs_release_file,
7891
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
7892 7893
};

7894
static struct extent_io_ops btrfs_extent_io_ops = {
7895
	.fill_delalloc = run_delalloc_range,
7896
	.submit_bio_hook = btrfs_submit_bio_hook,
7897
	.merge_bio_hook = btrfs_merge_bio_hook,
7898
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
7899
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
7900
	.writepage_start_hook = btrfs_writepage_start_hook,
7901 7902
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
7903 7904
	.merge_extent_hook = btrfs_merge_extent_hook,
	.split_extent_hook = btrfs_split_extent_hook,
7905 7906
};

7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918
/*
 * 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.
 */
7919
static const struct address_space_operations btrfs_aops = {
C
Chris Mason 已提交
7920 7921
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
7922
	.writepages	= btrfs_writepages,
7923
	.readpages	= btrfs_readpages,
7924
	.direct_IO	= btrfs_direct_IO,
7925 7926
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
7927
	.set_page_dirty	= btrfs_set_page_dirty,
7928
	.error_remove_page = generic_error_remove_page,
C
Chris Mason 已提交
7929 7930
};

7931
static const struct address_space_operations btrfs_symlink_aops = {
C
Chris Mason 已提交
7932 7933
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
7934 7935
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
7936 7937
};

7938
static const struct inode_operations btrfs_file_inode_operations = {
C
Chris Mason 已提交
7939 7940
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
7941 7942
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7943
	.listxattr      = btrfs_listxattr,
7944
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
7945
	.permission	= btrfs_permission,
Y
Yehuda Sadeh 已提交
7946
	.fiemap		= btrfs_fiemap,
7947
	.get_acl	= btrfs_get_acl,
7948
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
7949
};
7950
static const struct inode_operations btrfs_special_inode_operations = {
J
Josef Bacik 已提交
7951 7952
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
7953
	.permission	= btrfs_permission,
7954 7955
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7956
	.listxattr	= btrfs_listxattr,
7957
	.removexattr	= btrfs_removexattr,
7958
	.get_acl	= btrfs_get_acl,
7959
	.update_time	= btrfs_update_time,
J
Josef Bacik 已提交
7960
};
7961
static const struct inode_operations btrfs_symlink_inode_operations = {
C
Chris Mason 已提交
7962 7963 7964
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
7965
	.getattr	= btrfs_getattr,
7966
	.setattr	= btrfs_setattr,
Y
Yan 已提交
7967
	.permission	= btrfs_permission,
J
Jim Owens 已提交
7968 7969 7970 7971
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
7972
	.get_acl	= btrfs_get_acl,
7973
	.update_time	= btrfs_update_time,
C
Chris Mason 已提交
7974
};
7975

7976
const struct dentry_operations btrfs_dentry_operations = {
7977
	.d_delete	= btrfs_dentry_delete,
7978
	.d_release	= btrfs_dentry_release,
7979
};
反馈
建议
客服 返回
顶部