inode.c 198.0 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 74 75 76

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

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

90 91
static int btrfs_setsize(struct inode *inode, loff_t newsize);
static int btrfs_truncate(struct inode *inode);
92
static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
93 94 95 96
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);
97 98
static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode);
99

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

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

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

136
	if (compressed_size && compressed_pages)
137 138
		cur_size = compressed_size;

139 140
	path = btrfs_alloc_path();
	if (!path)
141 142
		return -ENOMEM;

143
	path->leave_spinning = 1;
144

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

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

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

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

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

211 212 213 214 215 216 217 218 219 220 221 222
	return 0;
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.
 */
223
static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
224 225
				 struct btrfs_root *root,
				 struct inode *inode, u64 start, u64 end,
226
				 size_t compressed_size, int compress_type,
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
				 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 hint_byte;
	u64 data_len = inline_len;
	int ret;

	if (compressed_size)
		data_len = compressed_size;

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

251
	ret = btrfs_drop_extents(trans, inode, start, aligned_end,
252
				 &hint_byte, 1);
253 254 255 256 257 258
	BUG_ON(ret);

	if (isize > actual_end)
		inline_len = min_t(u64, isize, actual_end);
	ret = insert_inline_extent(trans, root, inode, start,
				   inline_len, compressed_size,
259
				   compress_type, compressed_pages);
260
	BUG_ON(ret);
261
	btrfs_delalloc_release_metadata(inode, end + 1 - start);
262
	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
263 264 265
	return 0;
}

266 267 268 269 270 271
struct async_extent {
	u64 start;
	u64 ram_size;
	u64 compressed_size;
	struct page **pages;
	unsigned long nr_pages;
272
	int compress_type;
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
	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,
290 291
				     unsigned long nr_pages,
				     int compress_type)
292 293 294 295
{
	struct async_extent *async_extent;

	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
296
	BUG_ON(!async_extent);
297 298 299 300 301
	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;
302
	async_extent->compress_type = compress_type;
303 304 305 306
	list_add_tail(&async_extent->list, &cow->extents);
	return 0;
}

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

347 348 349 350
	/* if this is a small write inside eof, kick off a defragbot */
	if (end <= BTRFS_I(inode)->disk_i_size && (end - start + 1) < 16 * 1024)
		btrfs_add_inode_defrag(NULL, inode);

351
	actual_end = min_t(u64, isize, end + 1);
352 353 354 355
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);
356

357 358 359 360 361 362 363 364 365 366 367 368 369
	/*
	 * 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;

370 371 372 373
	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
374 375 376 377 378 379 380
	 * 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.
381 382
	 */
	total_compressed = min(total_compressed, max_uncompressed);
383
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
384
	num_bytes = max(blocksize,  num_bytes);
385 386
	total_in = 0;
	ret = 0;
387

388 389 390 391
	/*
	 * 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.
392
	 */
393
	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
394
	    (btrfs_test_opt(root, COMPRESS) ||
395 396
	     (BTRFS_I(inode)->force_compress) ||
	     (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
397
		WARN_ON(pages);
398
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
399 400 401 402
		if (!pages) {
			/* just bail out to the uncompressed code */
			goto cont;
		}
403

404 405 406 407 408 409 410 411 412 413
		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);
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432

		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) {
				kaddr = kmap_atomic(page, KM_USER0);
				memset(kaddr + offset, 0,
				       PAGE_CACHE_SIZE - offset);
				kunmap_atomic(kaddr, KM_USER0);
			}
			will_compress = 1;
		}
	}
433
cont:
434
	if (start == 0) {
435
		trans = btrfs_join_transaction(root);
436
		BUG_ON(IS_ERR(trans));
437
		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
438

439
		/* lets try to make an inline extent */
440
		if (ret || total_in < (actual_end - start)) {
441
			/* we didn't compress the entire range, try
442
			 * to make an uncompressed inline extent.
443 444
			 */
			ret = cow_file_range_inline(trans, root, inode,
445
						    start, end, 0, 0, NULL);
446
		} else {
447
			/* try making a compressed inline extent */
448 449
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
450 451
						    total_compressed,
						    compress_type, pages);
452 453
		}
		if (ret == 0) {
454 455 456 457 458
			/*
			 * inline extent creation worked, we don't need
			 * to create any more async work items.  Unlock
			 * and free up our temp pages.
			 */
459
			extent_clear_unlock_delalloc(inode,
460 461 462
			     &BTRFS_I(inode)->io_tree,
			     start, end, NULL,
			     EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
463
			     EXTENT_CLEAR_DELALLOC |
464
			     EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
465 466

			btrfs_end_transaction(trans, root);
467 468
			goto free_pages_out;
		}
469
		btrfs_end_transaction(trans, root);
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
	}

	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++) {
499
			WARN_ON(pages[i]->mapping);
500 501 502 503 504 505 506 507
			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 */
508 509
		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
		    !(BTRFS_I(inode)->force_compress)) {
510
			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
511
		}
512
	}
513 514
	if (will_compress) {
		*num_added += 1;
515

516 517 518 519 520
		/* 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,
521 522
				 total_compressed, pages, nr_pages_ret,
				 compress_type);
523

524
		if (start + num_bytes < end) {
525 526 527 528 529 530
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
531
cleanup_and_bail_uncompressed:
532 533 534 535 536 537 538 539 540 541 542 543
		/*
		 * 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 */
		}
544 545
		add_async_extent(async_cow, start, end - start + 1,
				 0, NULL, 0, BTRFS_COMPRESS_NONE);
546 547
		*num_added += 1;
	}
548

549 550 551 552 553 554 555 556
out:
	return 0;

free_pages_out:
	for (i = 0; i < nr_pages_ret; i++) {
		WARN_ON(pages[i]->mapping);
		page_cache_release(pages[i]);
	}
557
	kfree(pages);
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578

	goto out;
}

/*
 * phase two of compressed writeback.  This is the ordered portion
 * of the code, which only gets called in the order the work was
 * queued.  We walk all the async extents created by compress_file_range
 * and send them down to the disk.
 */
static noinline int submit_compressed_extents(struct inode *inode,
					      struct async_cow *async_cow)
{
	struct async_extent *async_extent;
	u64 alloc_hint = 0;
	struct btrfs_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;
579
	int ret = 0;
580 581 582 583 584

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


585
	while (!list_empty(&async_cow->extents)) {
586 587 588
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
589

590 591
		io_tree = &BTRFS_I(inode)->io_tree;

592
retry:
593 594 595 596 597 598
		/* 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,
599 600
					 async_extent->start +
					 async_extent->ram_size - 1, GFP_NOFS);
601 602

			/* allocate blocks */
603 604 605 606 607
			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);
608 609 610 611 612 613 614

			/*
			 * 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.
			 */
615
			if (!page_started && !ret)
616 617
				extent_write_locked_range(io_tree,
						  inode, async_extent->start,
618
						  async_extent->start +
619 620 621 622 623 624 625 626 627 628 629 630
						  async_extent->ram_size - 1,
						  btrfs_get_extent,
						  WB_SYNC_ALL);
			kfree(async_extent);
			cond_resched();
			continue;
		}

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

631
		trans = btrfs_join_transaction(root);
632
		BUG_ON(IS_ERR(trans));
633
		trans->block_rsv = &root->fs_info->delalloc_block_rsv;
634 635 636 637 638
		ret = btrfs_reserve_extent(trans, root,
					   async_extent->compressed_size,
					   async_extent->compressed_size,
					   0, alloc_hint,
					   (u64)-1, &ins, 1);
639 640
		btrfs_end_transaction(trans, root);

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
		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 +
				      async_extent->ram_size - 1, GFP_NOFS);
			goto retry;
		}

656 657 658 659 660 661 662 663
		/*
		 * 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);

664
		em = alloc_extent_map();
665
		BUG_ON(!em);
666 667
		em->start = async_extent->start;
		em->len = async_extent->ram_size;
668
		em->orig_start = em->start;
669

670 671 672
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
		em->bdev = root->fs_info->fs_devices->latest_bdev;
673
		em->compress_type = async_extent->compress_type;
674 675 676
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);

677
		while (1) {
678
			write_lock(&em_tree->lock);
679
			ret = add_extent_mapping(em_tree, em);
680
			write_unlock(&em_tree->lock);
681 682 683 684 685 686 687 688 689
			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);
		}

690 691 692 693 694 695 696
		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);
697 698 699 700 701 702
		BUG_ON(ret);

		/*
		 * clear dirty, set writeback and unlock the pages.
		 */
		extent_clear_unlock_delalloc(inode,
703 704 705 706 707 708
				&BTRFS_I(inode)->io_tree,
				async_extent->start,
				async_extent->start +
				async_extent->ram_size - 1,
				NULL, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK |
709
				EXTENT_CLEAR_DELALLOC |
710
				EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
711 712

		ret = btrfs_submit_compressed_write(inode,
713 714 715 716 717
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
718 719 720 721 722 723 724 725 726 727

		BUG_ON(ret);
		alloc_hint = ins.objectid + ins.offset;
		kfree(async_extent);
		cond_resched();
	}

	return 0;
}

728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
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;
}

760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
/*
 * 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.
 */
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_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	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;

792
	BUG_ON(btrfs_is_free_space_inode(root, inode));
793
	trans = btrfs_join_transaction(root);
794
	BUG_ON(IS_ERR(trans));
795
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
796 797 798 799 800 801

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

802 803 804 805
	/* if this is a small write inside eof, kick off defrag */
	if (end <= BTRFS_I(inode)->disk_i_size && num_bytes < 64 * 1024)
		btrfs_add_inode_defrag(trans, inode);

806 807 808
	if (start == 0) {
		/* lets try to make an inline extent */
		ret = cow_file_range_inline(trans, root, inode,
809
					    start, end, 0, 0, NULL);
810 811
		if (ret == 0) {
			extent_clear_unlock_delalloc(inode,
812 813 814 815 816 817 818 819
				     &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);
820

821 822 823 824 825 826 827 828 829
			*nr_written = *nr_written +
			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
			*page_started = 1;
			ret = 0;
			goto out;
		}
	}

	BUG_ON(disk_num_bytes >
830
	       btrfs_super_total_bytes(root->fs_info->super_copy));
831

832
	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
833 834
	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

835
	while (disk_num_bytes > 0) {
836 837
		unsigned long op;

838
		cur_alloc_size = disk_num_bytes;
839
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
840
					   root->sectorsize, 0, alloc_hint,
841
					   (u64)-1, &ins, 1);
842 843
		BUG_ON(ret);

844
		em = alloc_extent_map();
845
		BUG_ON(!em);
846
		em->start = start;
847
		em->orig_start = em->start;
848 849
		ram_size = ins.offset;
		em->len = ins.offset;
850

851
		em->block_start = ins.objectid;
852
		em->block_len = ins.offset;
853
		em->bdev = root->fs_info->fs_devices->latest_bdev;
854
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
855

856
		while (1) {
857
			write_lock(&em_tree->lock);
858
			ret = add_extent_mapping(em_tree, em);
859
			write_unlock(&em_tree->lock);
860 861 862 863 864
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, start,
865
						start + ram_size - 1, 0);
866 867
		}

868
		cur_alloc_size = ins.offset;
869
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
870
					       ram_size, cur_alloc_size, 0);
871
		BUG_ON(ret);
872

873 874 875 876 877 878 879
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, start,
						      cur_alloc_size);
			BUG_ON(ret);
		}

880
		if (disk_num_bytes < cur_alloc_size)
881
			break;
882

883 884 885
		/* 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
886 887 888
		 *
		 * Do set the Private2 bit so we know this page was properly
		 * setup for writepage
889
		 */
890 891 892 893
		op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
		op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
			EXTENT_SET_PRIVATE2;

894 895
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					     start, start + ram_size - 1,
896
					     locked_page, op);
897
		disk_num_bytes -= cur_alloc_size;
898 899 900
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
901 902
	}
out:
903
	ret = 0;
904
	btrfs_end_transaction(trans, root);
905

906
	return ret;
907
}
908

909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
/*
 * 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);
	if (num_added == 0)
		async_cow->inode = NULL;
}

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

	atomic_sub(nr_pages, &root->fs_info->async_delalloc_pages);

	if (atomic_read(&root->fs_info->async_delalloc_pages) <
	    5 * 1042 * 1024 &&
	    waitqueue_active(&root->fs_info->async_submit_wait))
		wake_up(&root->fs_info->async_submit_wait);

947
	if (async_cow->inode)
948 949
		submit_compressed_extents(async_cow->inode, async_cow);
}
950

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
static noinline void async_cow_free(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	async_cow = container_of(work, struct async_cow, work);
	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;
	int limit = 10 * 1024 * 1042;

968 969
	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
			 1, 0, NULL, GFP_NOFS);
970
	while (start < end) {
971
		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
972
		BUG_ON(!async_cow);
973 974 975 976 977
		async_cow->inode = inode;
		async_cow->root = root;
		async_cow->locked_page = locked_page;
		async_cow->start = start;

978
		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
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
			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));
		}

1004
		while (atomic_read(&root->fs_info->async_submit_draining) &&
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
		      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;
1016 1017
}

1018
static noinline int csum_exist_in_range(struct btrfs_root *root,
1019 1020 1021 1022 1023 1024
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

1025
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
A
Arne Jansen 已提交
1026
				       bytenr + num_bytes - 1, &list, 0);
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
	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;
}

1038 1039 1040 1041 1042 1043 1044
/*
 * 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
 */
1045 1046
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
1047 1048
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
1049 1050
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1051
	struct btrfs_trans_handle *trans;
1052 1053
	struct extent_buffer *leaf;
	struct btrfs_path *path;
1054
	struct btrfs_file_extent_item *fi;
1055
	struct btrfs_key found_key;
1056 1057 1058
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
1059
	u64 extent_offset;
1060 1061 1062 1063
	u64 disk_bytenr;
	u64 num_bytes;
	int extent_type;
	int ret;
1064
	int type;
1065 1066
	int nocow;
	int check_prev = 1;
1067
	bool nolock;
1068
	u64 ino = btrfs_ino(inode);
1069 1070

	path = btrfs_alloc_path();
1071 1072
	if (!path)
		return -ENOMEM;
1073

1074
	nolock = btrfs_is_free_space_inode(root, inode);
1075 1076

	if (nolock)
1077
		trans = btrfs_join_transaction_nolock(root);
1078
	else
1079
		trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
1080

1081
	BUG_ON(IS_ERR(trans));
1082
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1083

1084 1085 1086
	cow_start = (u64)-1;
	cur_offset = start;
	while (1) {
1087
		ret = btrfs_lookup_file_extent(trans, root, path, ino,
1088 1089 1090 1091 1092 1093
					       cur_offset, 0);
		BUG_ON(ret < 0);
		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);
1094
			if (found_key.objectid == ino &&
1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
			    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);
			if (ret < 0)
				BUG_ON(1);
			if (ret > 0)
				break;
			leaf = path->nodes[0];
		}
1109

1110 1111
		nocow = 0;
		disk_bytenr = 0;
1112
		num_bytes = 0;
1113 1114
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

1115
		if (found_key.objectid > ino ||
1116 1117 1118 1119 1120 1121
		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
		    found_key.offset > end)
			break;

		if (found_key.offset > cur_offset) {
			extent_end = found_key.offset;
1122
			extent_type = 0;
1123 1124 1125 1126 1127 1128 1129
			goto out_check;
		}

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

1130 1131
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1132
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1133
			extent_offset = btrfs_file_extent_offset(leaf, fi);
1134 1135 1136 1137 1138 1139
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1140 1141
			if (disk_bytenr == 0)
				goto out_check;
1142 1143 1144 1145
			if (btrfs_file_extent_compression(leaf, fi) ||
			    btrfs_file_extent_encryption(leaf, fi) ||
			    btrfs_file_extent_other_encoding(leaf, fi))
				goto out_check;
1146 1147
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1148
			if (btrfs_extent_readonly(root, disk_bytenr))
1149
				goto out_check;
1150
			if (btrfs_cross_ref_exist(trans, root, ino,
1151 1152
						  found_key.offset -
						  extent_offset, disk_bytenr))
1153
				goto out_check;
1154
			disk_bytenr += extent_offset;
1155 1156 1157 1158 1159 1160 1161 1162 1163
			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;
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
			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;
1185 1186
		}

1187
		btrfs_release_path(path);
1188 1189
		if (cow_start != (u64)-1) {
			ret = cow_file_range(inode, locked_page, cow_start,
1190 1191
					found_key.offset - 1, page_started,
					nr_written, 1);
1192 1193
			BUG_ON(ret);
			cow_start = (u64)-1;
1194
		}
1195

1196 1197 1198 1199
		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
			struct extent_map *em;
			struct extent_map_tree *em_tree;
			em_tree = &BTRFS_I(inode)->extent_tree;
1200
			em = alloc_extent_map();
1201
			BUG_ON(!em);
1202
			em->start = cur_offset;
1203
			em->orig_start = em->start;
1204 1205 1206 1207 1208 1209
			em->len = num_bytes;
			em->block_len = num_bytes;
			em->block_start = disk_bytenr;
			em->bdev = root->fs_info->fs_devices->latest_bdev;
			set_bit(EXTENT_FLAG_PINNED, &em->flags);
			while (1) {
1210
				write_lock(&em_tree->lock);
1211
				ret = add_extent_mapping(em_tree, em);
1212
				write_unlock(&em_tree->lock);
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
				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;
		}
1224 1225

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1226 1227
					       num_bytes, num_bytes, type);
		BUG_ON(ret);
1228

1229 1230 1231 1232 1233 1234 1235
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, cur_offset,
						      num_bytes);
			BUG_ON(ret);
		}

1236
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1237 1238 1239 1240
				cur_offset, cur_offset + num_bytes - 1,
				locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
				EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
				EXTENT_SET_PRIVATE2);
1241 1242 1243
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1244
	}
1245
	btrfs_release_path(path);
1246 1247 1248 1249 1250

	if (cur_offset <= end && cow_start == (u64)-1)
		cow_start = cur_offset;
	if (cow_start != (u64)-1) {
		ret = cow_file_range(inode, locked_page, cow_start, end,
1251
				     page_started, nr_written, 1);
1252 1253 1254
		BUG_ON(ret);
	}

1255 1256 1257 1258 1259 1260 1261
	if (nolock) {
		ret = btrfs_end_transaction_nolock(trans, root);
		BUG_ON(ret);
	} else {
		ret = btrfs_end_transaction(trans, root);
		BUG_ON(ret);
	}
1262
	btrfs_free_path(path);
1263
	return 0;
1264 1265
}

1266 1267 1268
/*
 * extent_io.c call back to do delayed allocation processing
 */
1269
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1270 1271
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1272 1273
{
	int ret;
1274
	struct btrfs_root *root = BTRFS_I(inode)->root;
1275

1276
	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)
1277
		ret = run_delalloc_nocow(inode, locked_page, start, end,
1278
					 page_started, 1, nr_written);
1279
	else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)
1280
		ret = run_delalloc_nocow(inode, locked_page, start, end,
1281
					 page_started, 0, nr_written);
1282
	else if (!btrfs_test_opt(root, COMPRESS) &&
1283 1284
		 !(BTRFS_I(inode)->force_compress) &&
		 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
1285 1286
		ret = cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
1287
	else
1288
		ret = cow_file_range_async(inode, locked_page, start, end,
1289
					   page_started, nr_written);
1290 1291 1292
	return ret;
}

1293 1294
static void btrfs_split_extent_hook(struct inode *inode,
				    struct extent_state *orig, u64 split)
1295
{
1296
	/* not delalloc, ignore it */
1297
	if (!(orig->state & EXTENT_DELALLOC))
1298
		return;
1299

1300 1301 1302
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;
	spin_unlock(&BTRFS_I(inode)->lock);
1303 1304 1305 1306 1307 1308 1309 1310
}

/*
 * 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.
 */
1311 1312 1313
static void btrfs_merge_extent_hook(struct inode *inode,
				    struct extent_state *new,
				    struct extent_state *other)
1314 1315 1316
{
	/* not delalloc, ignore it */
	if (!(other->state & EXTENT_DELALLOC))
1317
		return;
1318

1319 1320 1321
	spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents--;
	spin_unlock(&BTRFS_I(inode)->lock);
1322 1323
}

1324 1325 1326 1327 1328
/*
 * 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.
 */
1329 1330
static void btrfs_set_bit_hook(struct inode *inode,
			       struct extent_state *state, int *bits)
1331
{
1332

1333 1334
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1335
	 * but in this case, we are only testing for the DELALLOC
1336 1337
	 * bit, which is only set or cleared with irqs on
	 */
1338
	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1339
		struct btrfs_root *root = BTRFS_I(inode)->root;
1340
		u64 len = state->end + 1 - state->start;
1341
		bool do_list = !btrfs_is_free_space_inode(root, inode);
1342

1343
		if (*bits & EXTENT_FIRST_DELALLOC) {
1344
			*bits &= ~EXTENT_FIRST_DELALLOC;
1345 1346 1347 1348 1349
		} else {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents++;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1350

1351
		spin_lock(&root->fs_info->delalloc_lock);
1352 1353
		BTRFS_I(inode)->delalloc_bytes += len;
		root->fs_info->delalloc_bytes += len;
1354
		if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1355 1356 1357
			list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
				      &root->fs_info->delalloc_inodes);
		}
1358
		spin_unlock(&root->fs_info->delalloc_lock);
1359 1360 1361
	}
}

1362 1363 1364
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1365 1366
static void btrfs_clear_bit_hook(struct inode *inode,
				 struct extent_state *state, int *bits)
1367
{
1368 1369
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
1370
	 * but in this case, we are only testing for the DELALLOC
1371 1372
	 * bit, which is only set or cleared with irqs on
	 */
1373
	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1374
		struct btrfs_root *root = BTRFS_I(inode)->root;
1375
		u64 len = state->end + 1 - state->start;
1376
		bool do_list = !btrfs_is_free_space_inode(root, inode);
1377

1378
		if (*bits & EXTENT_FIRST_DELALLOC) {
1379
			*bits &= ~EXTENT_FIRST_DELALLOC;
1380 1381 1382 1383 1384
		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
			spin_lock(&BTRFS_I(inode)->lock);
			BTRFS_I(inode)->outstanding_extents--;
			spin_unlock(&BTRFS_I(inode)->lock);
		}
1385 1386 1387 1388

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

1389 1390
		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
		    && do_list)
1391
			btrfs_free_reserved_data_space(inode, len);
1392

1393
		spin_lock(&root->fs_info->delalloc_lock);
1394 1395 1396
		root->fs_info->delalloc_bytes -= len;
		BTRFS_I(inode)->delalloc_bytes -= len;

1397
		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1398 1399 1400
		    !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
			list_del_init(&BTRFS_I(inode)->delalloc_inodes);
		}
1401
		spin_unlock(&root->fs_info->delalloc_lock);
1402 1403 1404
	}
}

1405 1406 1407 1408
/*
 * 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
 */
1409
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
1410 1411
			 size_t size, struct bio *bio,
			 unsigned long bio_flags)
1412 1413 1414
{
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct btrfs_mapping_tree *map_tree;
1415
	u64 logical = (u64)bio->bi_sector << 9;
1416 1417 1418 1419
	u64 length = 0;
	u64 map_length;
	int ret;

1420 1421 1422
	if (bio_flags & EXTENT_BIO_COMPRESSED)
		return 0;

1423
	length = bio->bi_size;
1424 1425
	map_tree = &root->fs_info->mapping_tree;
	map_length = length;
1426
	ret = btrfs_map_block(map_tree, READ, logical,
1427
			      &map_length, NULL, 0);
1428 1429
	/* Will always return 0 or 1 with map_multi == NULL */
	BUG_ON(ret < 0);
1430
	if (map_length < length + size)
1431
		return 1;
1432
	return 0;
1433 1434
}

1435 1436 1437 1438 1439 1440 1441 1442
/*
 * 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
 */
1443 1444
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
1445 1446
				    unsigned long bio_flags,
				    u64 bio_offset)
1447 1448 1449
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1450

1451
	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1452
	BUG_ON(ret);
1453 1454
	return 0;
}
1455

1456 1457 1458 1459 1460 1461 1462 1463
/*
 * 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
 */
1464
static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1465 1466
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1467 1468
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1469
	return btrfs_map_bio(root, rw, bio, mirror_num, 1);
1470 1471
}

1472
/*
1473 1474
 * 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
1475
 */
1476
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1477 1478
			  int mirror_num, unsigned long bio_flags,
			  u64 bio_offset)
1479 1480 1481
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1482
	int skip_sum;
1483
	int metadata = 0;
1484

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

1487
	if (btrfs_is_free_space_inode(root, inode))
1488 1489 1490
		metadata = 2;

	ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
1491
	BUG_ON(ret);
1492

1493
	if (!(rw & REQ_WRITE)) {
1494
		if (bio_flags & EXTENT_BIO_COMPRESSED) {
1495 1496
			return btrfs_submit_compressed_read(inode, bio,
						    mirror_num, bio_flags);
1497 1498 1499 1500 1501
		} else if (!skip_sum) {
			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
			if (ret)
				return ret;
		}
1502
		goto mapit;
1503
	} else if (!skip_sum) {
1504 1505 1506
		/* csum items have already been cloned */
		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
			goto mapit;
1507 1508
		/* we're doing a write, do the async checksumming */
		return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1509
				   inode, rw, bio, mirror_num,
1510 1511
				   bio_flags, bio_offset,
				   __btrfs_submit_bio_start,
1512
				   __btrfs_submit_bio_done);
1513 1514
	}

1515
mapit:
1516
	return btrfs_map_bio(root, rw, bio, mirror_num, 0);
1517
}
C
Chris Mason 已提交
1518

1519 1520 1521 1522
/*
 * 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.
 */
1523
static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1524 1525 1526 1527 1528
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

1529
	list_for_each_entry(sum, list, list) {
1530 1531
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
1532 1533 1534 1535
	}
	return 0;
}

1536 1537
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
			      struct extent_state **cached_state)
1538
{
1539
	if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
1540
		WARN_ON(1);
1541
	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1542
				   cached_state, GFP_NOFS);
1543 1544
}

1545
/* see btrfs_writepage_start_hook for details on why this is required */
1546 1547 1548 1549 1550
struct btrfs_writepage_fixup {
	struct page *page;
	struct btrfs_work work;
};

1551
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1552 1553 1554
{
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_ordered_extent *ordered;
1555
	struct extent_state *cached_state = NULL;
1556 1557 1558 1559
	struct page *page;
	struct inode *inode;
	u64 page_start;
	u64 page_end;
1560
	int ret;
1561 1562 1563

	fixup = container_of(work, struct btrfs_writepage_fixup, work);
	page = fixup->page;
C
Chris Mason 已提交
1564
again:
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
	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;

1575 1576
	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
			 &cached_state, GFP_NOFS);
C
Chris Mason 已提交
1577 1578

	/* already ordered? We're done */
1579
	if (PagePrivate2(page))
1580
		goto out;
C
Chris Mason 已提交
1581 1582 1583

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
1584 1585
		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
				     page_end, &cached_state, GFP_NOFS);
C
Chris Mason 已提交
1586 1587
		unlock_page(page);
		btrfs_start_ordered_extent(inode, ordered, 1);
1588
		btrfs_put_ordered_extent(ordered);
C
Chris Mason 已提交
1589 1590
		goto again;
	}
1591

1592 1593 1594 1595 1596 1597 1598 1599
	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;
	 }

1600
	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1601
	ClearPageChecked(page);
1602
	set_page_dirty(page);
1603
out:
1604 1605
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
			     &cached_state, GFP_NOFS);
1606 1607 1608
out_page:
	unlock_page(page);
	page_cache_release(page);
1609
	kfree(fixup);
1610 1611 1612 1613 1614 1615 1616 1617
}

/*
 * 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.
 *
1618
 * In our case any range that doesn't have the ORDERED bit set
1619 1620 1621 1622
 * 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.
 */
1623
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1624 1625 1626 1627 1628
{
	struct inode *inode = page->mapping->host;
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_root *root = BTRFS_I(inode)->root;

1629 1630
	/* this page is properly in the ordered list */
	if (TestClearPagePrivate2(page))
1631 1632 1633 1634 1635 1636 1637 1638
		return 0;

	if (PageChecked(page))
		return -EAGAIN;

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

1640 1641 1642 1643 1644
	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);
1645
	return -EBUSY;
1646 1647
}

1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
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;
	u64 hint;
	int ret;

	path = btrfs_alloc_path();
1664 1665
	if (!path)
		return -ENOMEM;
1666

1667
	path->leave_spinning = 1;
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677

	/*
	 * 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.
	 */
1678 1679
	ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
				 &hint, 0);
1680 1681
	BUG_ON(ret);

1682
	ins.objectid = btrfs_ino(inode);
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
	ins.offset = file_pos;
	ins.type = BTRFS_EXTENT_DATA_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
	BUG_ON(ret);
	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);
1700 1701 1702 1703

	btrfs_unlock_up_safe(path, 1);
	btrfs_set_lock_blocking(leaf);

1704 1705 1706 1707 1708 1709 1710
	btrfs_mark_buffer_dirty(leaf);

	inode_add_bytes(inode, num_bytes);

	ins.objectid = disk_bytenr;
	ins.offset = disk_num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
1711 1712
	ret = btrfs_alloc_reserved_file_extent(trans, root,
					root->root_key.objectid,
1713
					btrfs_ino(inode), file_pos, &ins);
1714 1715
	BUG_ON(ret);
	btrfs_free_path(path);
1716

1717 1718 1719
	return 0;
}

1720 1721 1722 1723 1724 1725
/*
 * 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.
 */
1726 1727 1728 1729
/* 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.
 */
1730
static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1731 1732
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1733
	struct btrfs_trans_handle *trans = NULL;
1734
	struct btrfs_ordered_extent *ordered_extent = NULL;
1735
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1736
	struct extent_state *cached_state = NULL;
1737
	int compress_type = 0;
1738
	int ret;
1739
	bool nolock;
1740

1741 1742
	ret = btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
					     end - start + 1);
1743
	if (!ret)
1744 1745
		return 0;
	BUG_ON(!ordered_extent);
1746

1747
	nolock = btrfs_is_free_space_inode(root, inode);
1748

1749 1750 1751 1752
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
		BUG_ON(!list_empty(&ordered_extent->list));
		ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
		if (!ret) {
1753
			if (nolock)
1754
				trans = btrfs_join_transaction_nolock(root);
1755
			else
1756
				trans = btrfs_join_transaction(root);
1757
			BUG_ON(IS_ERR(trans));
1758
			trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1759
			ret = btrfs_update_inode_fallback(trans, root, inode);
1760 1761 1762 1763
			BUG_ON(ret);
		}
		goto out;
	}
1764

1765 1766 1767
	lock_extent_bits(io_tree, ordered_extent->file_offset,
			 ordered_extent->file_offset + ordered_extent->len - 1,
			 0, &cached_state, GFP_NOFS);
1768

1769
	if (nolock)
1770
		trans = btrfs_join_transaction_nolock(root);
1771
	else
1772
		trans = btrfs_join_transaction(root);
1773
	BUG_ON(IS_ERR(trans));
1774
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1775

1776
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
1777
		compress_type = ordered_extent->compress_type;
1778
	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1779
		BUG_ON(compress_type);
1780
		ret = btrfs_mark_extent_written(trans, inode,
1781 1782 1783 1784 1785
						ordered_extent->file_offset,
						ordered_extent->file_offset +
						ordered_extent->len);
		BUG_ON(ret);
	} else {
1786
		BUG_ON(root == root->fs_info->tree_root);
1787 1788 1789 1790 1791 1792
		ret = insert_reserved_file_extent(trans, inode,
						ordered_extent->file_offset,
						ordered_extent->start,
						ordered_extent->disk_len,
						ordered_extent->len,
						ordered_extent->len,
1793
						compress_type, 0, 0,
1794
						BTRFS_FILE_EXTENT_REG);
1795 1796 1797
		unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
				   ordered_extent->file_offset,
				   ordered_extent->len);
1798 1799
		BUG_ON(ret);
	}
1800 1801 1802 1803
	unlock_extent_cached(io_tree, ordered_extent->file_offset,
			     ordered_extent->file_offset +
			     ordered_extent->len - 1, &cached_state, GFP_NOFS);

1804 1805 1806
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

1807
	ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
1808
	if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
1809
		ret = btrfs_update_inode_fallback(trans, root, inode);
1810 1811 1812
		BUG_ON(ret);
	}
	ret = 0;
1813
out:
1814
	if (root != root->fs_info->tree_root)
1815
		btrfs_delalloc_release_metadata(inode, ordered_extent->len);
1816 1817
	if (trans) {
		if (nolock)
1818
			btrfs_end_transaction_nolock(trans, root);
1819
		else
1820 1821 1822
			btrfs_end_transaction(trans, root);
	}

1823 1824 1825 1826 1827 1828 1829 1830
	/* once for us */
	btrfs_put_ordered_extent(ordered_extent);
	/* once for the tree */
	btrfs_put_ordered_extent(ordered_extent);

	return 0;
}

1831
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1832 1833
				struct extent_state *state, int uptodate)
{
1834 1835
	trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);

1836
	ClearPagePrivate2(page);
1837 1838 1839
	return btrfs_finish_ordered_io(page->mapping->host, start, end);
}

1840 1841
/*
 * when reads are done, we need to check csums to verify the data is correct
1842 1843
 * 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.
1844
 */
1845
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1846
			       struct extent_state *state)
1847
{
1848
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1849
	struct inode *inode = page->mapping->host;
1850
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1851
	char *kaddr;
1852
	u64 private = ~(u32)0;
1853
	int ret;
1854 1855
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
1856

1857 1858 1859 1860
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
1861 1862

	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
1863
		goto good;
1864 1865

	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
1866
	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
1867 1868
		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
				  GFP_NOFS);
1869
		return 0;
1870
	}
1871

Y
Yan 已提交
1872
	if (state && state->start == start) {
1873 1874 1875 1876 1877
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
1878
	kaddr = kmap_atomic(page, KM_USER0);
1879
	if (ret)
1880
		goto zeroit;
1881

1882 1883
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
1884
	if (csum != private)
1885
		goto zeroit;
1886

1887
	kunmap_atomic(kaddr, KM_USER0);
1888
good:
1889 1890 1891
	return 0;

zeroit:
1892
	printk_ratelimited(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
1893 1894
		       "private %llu\n",
		       (unsigned long long)btrfs_ino(page->mapping->host),
1895 1896
		       (unsigned long long)start, csum,
		       (unsigned long long)private);
1897 1898
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
1899
	kunmap_atomic(kaddr, KM_USER0);
1900 1901
	if (private == 0)
		return 0;
1902
	return -EIO;
1903
}
1904

Y
Yan, Zheng 已提交
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
struct delayed_iput {
	struct list_head list;
	struct inode *inode;
};

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;

	down_read(&root->fs_info->cleanup_work_sem);
	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);
	}
	up_read(&root->fs_info->cleanup_work_sem);
}

1953 1954 1955 1956 1957 1958
enum btrfs_orphan_cleanup_state {
	ORPHAN_CLEANUP_STARTED	= 1,
	ORPHAN_CLEANUP_DONE	= 2,
};

/*
1959
 * This is called in transaction commit time. If there are no orphan
1960 1961 1962 1963 1964 1965
 * 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)
{
1966
	struct btrfs_block_rsv *block_rsv;
1967 1968 1969 1970 1971 1972
	int ret;

	if (!list_empty(&root->orphan_list) ||
	    root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
		return;

1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
	spin_lock(&root->orphan_lock);
	if (!list_empty(&root->orphan_list)) {
		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);

1988 1989 1990 1991 1992 1993 1994 1995
	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;
	}

1996 1997 1998
	if (block_rsv) {
		WARN_ON(block_rsv->size > 0);
		btrfs_free_block_rsv(root, block_rsv);
1999 2000 2001
	}
}

2002 2003 2004
/*
 * This creates an orphan entry for the given inode in case something goes
 * wrong in the middle of an unlink/truncate.
2005 2006 2007
 *
 * NOTE: caller of this function should reserve 5 units of metadata for
 *	 this function.
2008 2009 2010 2011
 */
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
2012 2013 2014 2015
	struct btrfs_block_rsv *block_rsv = NULL;
	int reserve = 0;
	int insert = 0;
	int ret;
2016

2017 2018
	if (!root->orphan_block_rsv) {
		block_rsv = btrfs_alloc_block_rsv(root);
2019 2020
		if (!block_rsv)
			return -ENOMEM;
2021
	}
2022

2023 2024 2025 2026 2027 2028
	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;
2029 2030
	}

2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
	if (list_empty(&BTRFS_I(inode)->i_orphan)) {
		list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
#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;
2045 2046
	}

2047 2048 2049 2050 2051
	if (!BTRFS_I(inode)->orphan_meta_reserved) {
		BTRFS_I(inode)->orphan_meta_reserved = 1;
		reserve = 1;
	}
	spin_unlock(&root->orphan_lock);
2052

2053 2054 2055 2056 2057
	/* grab metadata reservation from transaction handle */
	if (reserve) {
		ret = btrfs_orphan_reserve_metadata(trans, inode);
		BUG_ON(ret);
	}
2058

2059 2060
	/* insert an orphan item to track this unlinked/truncated file */
	if (insert >= 1) {
2061
		ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
2062
		BUG_ON(ret && ret != -EEXIST);
2063 2064 2065 2066 2067 2068 2069 2070 2071
	}

	/* 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);
		BUG_ON(ret);
	}
	return 0;
2072 2073 2074 2075 2076 2077 2078 2079 2080
}

/*
 * 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;
2081 2082
	int delete_item = 0;
	int release_rsv = 0;
2083 2084
	int ret = 0;

2085 2086 2087 2088
	spin_lock(&root->orphan_lock);
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
		list_del_init(&BTRFS_I(inode)->i_orphan);
		delete_item = 1;
2089 2090
	}

2091 2092 2093
	if (BTRFS_I(inode)->orphan_meta_reserved) {
		BTRFS_I(inode)->orphan_meta_reserved = 0;
		release_rsv = 1;
2094
	}
2095
	spin_unlock(&root->orphan_lock);
2096

2097
	if (trans && delete_item) {
2098
		ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
2099 2100
		BUG_ON(ret);
	}
2101

2102 2103
	if (release_rsv)
		btrfs_orphan_release_metadata(inode);
2104

2105
	return 0;
2106 2107 2108 2109 2110 2111
}

/*
 * this cleans up any orphans that may be left on the list from the last use
 * of this root.
 */
2112
int btrfs_orphan_cleanup(struct btrfs_root *root)
2113 2114 2115 2116 2117 2118
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key, found_key;
	struct btrfs_trans_handle *trans;
	struct inode *inode;
2119
	u64 last_objectid = 0;
2120 2121
	int ret = 0, nr_unlink = 0, nr_truncate = 0;

2122
	if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
2123
		return 0;
2124 2125

	path = btrfs_alloc_path();
2126 2127 2128 2129
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}
2130 2131 2132 2133 2134 2135 2136 2137
	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);
2138 2139
		if (ret < 0)
			goto out;
2140 2141 2142

		/*
		 * if ret == 0 means we found what we were searching for, which
L
Lucas De Marchi 已提交
2143
		 * is weird, but possible, so only screw with path if we didn't
2144 2145 2146
		 * find the key and see if we have stuff that matches
		 */
		if (ret > 0) {
2147
			ret = 0;
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163
			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 */
2164
		btrfs_release_path(path);
2165 2166 2167 2168 2169 2170

		/*
		 * 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.
		 */
2171 2172 2173 2174 2175 2176 2177 2178 2179 2180

		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;

2181 2182 2183
		found_key.objectid = found_key.offset;
		found_key.type = BTRFS_INODE_ITEM_KEY;
		found_key.offset = 0;
2184
		inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
2185 2186
		ret = PTR_RET(inode);
		if (ret && ret != -ESTALE)
2187
			goto out;
2188

2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220
		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;
			}
		}
2221
		/*
2222 2223
		 * Inode is already gone but the orphan item is still there,
		 * kill the orphan item.
2224
		 */
2225 2226
		if (ret == -ESTALE) {
			trans = btrfs_start_transaction(root, 1);
2227 2228 2229 2230
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				goto out;
			}
2231 2232 2233
			ret = btrfs_del_orphan_item(trans, root,
						    found_key.objectid);
			BUG_ON(ret);
2234
			btrfs_end_transaction(trans, root);
2235 2236 2237
			continue;
		}

2238 2239 2240 2241 2242 2243 2244 2245
		/*
		 * add this inode to the orphan list so btrfs_orphan_del does
		 * the proper thing when we hit it
		 */
		spin_lock(&root->orphan_lock);
		list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
		spin_unlock(&root->orphan_lock);

2246 2247
		/* if we have links, this was a truncate, lets do that */
		if (inode->i_nlink) {
2248 2249 2250 2251 2252
			if (!S_ISREG(inode->i_mode)) {
				WARN_ON(1);
				iput(inode);
				continue;
			}
2253
			nr_truncate++;
2254
			ret = btrfs_truncate(inode);
2255 2256 2257 2258 2259 2260
		} else {
			nr_unlink++;
		}

		/* this will do delete_inode and everything for us */
		iput(inode);
2261 2262
		if (ret)
			goto out;
2263
	}
2264 2265 2266
	/* release the path since we're done with it */
	btrfs_release_path(path);

2267 2268 2269 2270 2271 2272 2273
	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) {
2274
		trans = btrfs_join_transaction(root);
2275 2276
		if (!IS_ERR(trans))
			btrfs_end_transaction(trans, root);
2277
	}
2278 2279 2280 2281 2282

	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);
2283 2284 2285 2286 2287 2288

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

2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
/*
 * 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;
}

2342 2343 2344
/*
 * read an inode from the btree into the in-memory inode
 */
2345
static void btrfs_read_locked_inode(struct inode *inode)
C
Chris Mason 已提交
2346 2347
{
	struct btrfs_path *path;
2348
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2349
	struct btrfs_inode_item *inode_item;
2350
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
2351 2352
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
2353
	int maybe_acls;
J
Josef Bacik 已提交
2354
	u32 rdev;
C
Chris Mason 已提交
2355
	int ret;
2356 2357 2358 2359 2360
	bool filled = false;

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

	path = btrfs_alloc_path();
2363 2364 2365
	if (!path)
		goto make_bad;

2366
	path->leave_spinning = 1;
C
Chris Mason 已提交
2367
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
2368

C
Chris Mason 已提交
2369
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2370
	if (ret)
C
Chris Mason 已提交
2371 2372
		goto make_bad;

2373
	leaf = path->nodes[0];
2374 2375 2376 2377

	if (filled)
		goto cache_acl;

2378 2379 2380
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_inode_item);
	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
2381
	set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
2382 2383
	inode->i_uid = btrfs_inode_uid(leaf, inode_item);
	inode->i_gid = btrfs_inode_gid(leaf, inode_item);
2384
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397

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

2398
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2399
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2400
	BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2401
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
2402
	inode->i_rdev = 0;
2403 2404
	rdev = btrfs_inode_rdev(leaf, inode_item);

2405
	BTRFS_I(inode)->index_cnt = (u64)-1;
2406
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2407
cache_acl:
2408 2409 2410 2411
	/*
	 * try to precache a NULL acl entry for files that don't have
	 * any xattrs or acls
	 */
2412 2413
	maybe_acls = acls_after_inode_item(leaf, path->slots[0],
					   btrfs_ino(inode));
2414 2415
	if (!maybe_acls)
		cache_no_acl(inode);
2416

C
Chris Mason 已提交
2417 2418 2419 2420 2421
	btrfs_free_path(path);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
2422
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2423
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
		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;
2437
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
2438
		break;
J
Josef Bacik 已提交
2439
	default:
J
Jim Owens 已提交
2440
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
2441 2442
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
2443
	}
2444 2445

	btrfs_update_iflags(inode);
C
Chris Mason 已提交
2446 2447 2448 2449 2450 2451 2452
	return;

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

2453 2454 2455
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
2456 2457
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
2458
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
2459 2460
			    struct inode *inode)
{
2461 2462
	btrfs_set_inode_uid(leaf, item, inode->i_uid);
	btrfs_set_inode_gid(leaf, item, inode->i_gid);
2463
	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
	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);

2482
	btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2483
	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2484
	btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2485
	btrfs_set_inode_transid(leaf, item, trans->transid);
2486
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
Y
Yan 已提交
2487
	btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2488
	btrfs_set_inode_block_group(leaf, item, 0);
C
Chris Mason 已提交
2489 2490
}

2491 2492 2493
/*
 * copy everything in the in-memory inode into the btree.
 */
2494
static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
2495
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
2496 2497 2498
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
2499
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2500 2501 2502
	int ret;

	path = btrfs_alloc_path();
2503 2504 2505
	if (!path)
		return -ENOMEM;

2506
	path->leave_spinning = 1;
2507 2508
	ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
				 1);
C
Chris Mason 已提交
2509 2510 2511 2512 2513 2514
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

2515
	btrfs_unlock_up_safe(path, 1);
2516 2517
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
2518
				    struct btrfs_inode_item);
C
Chris Mason 已提交
2519

2520
	fill_inode_item(trans, leaf, inode_item, inode);
2521
	btrfs_mark_buffer_dirty(leaf);
2522
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
2523 2524 2525 2526 2527 2528
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}

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
/*
 * 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
	 */
	if (!btrfs_is_free_space_inode(root, inode)
	    && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
		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);
}

static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode)
{
	int ret;

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

2566 2567 2568 2569 2570
/*
 * 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
 */
2571 2572 2573 2574
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 已提交
2575 2576 2577
{
	struct btrfs_path *path;
	int ret = 0;
2578
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2579
	struct btrfs_dir_item *di;
2580
	struct btrfs_key key;
2581
	u64 index;
2582 2583
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
C
Chris Mason 已提交
2584 2585

	path = btrfs_alloc_path();
2586 2587
	if (!path) {
		ret = -ENOMEM;
2588
		goto out;
2589 2590
	}

2591
	path->leave_spinning = 1;
2592
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
C
Chris Mason 已提交
2593 2594 2595 2596 2597 2598 2599 2600 2601
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
2602 2603
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
2604
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2605 2606
	if (ret)
		goto err;
2607
	btrfs_release_path(path);
C
Chris Mason 已提交
2608

2609 2610
	ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
				  dir_ino, &index);
2611
	if (ret) {
2612
		printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2613 2614
		       "inode %llu parent %llu\n", name_len, name,
		       (unsigned long long)ino, (unsigned long long)dir_ino);
2615 2616 2617
		goto err;
	}

2618 2619
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
	if (ret)
C
Chris Mason 已提交
2620 2621
		goto err;

2622
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
2623
					 inode, dir_ino);
2624
	BUG_ON(ret != 0 && ret != -ENOENT);
2625 2626 2627

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
2628 2629
	if (ret == -ENOENT)
		ret = 0;
C
Chris Mason 已提交
2630 2631
err:
	btrfs_free_path(path);
2632 2633 2634 2635 2636 2637 2638
	if (ret)
		goto out;

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
	inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
	btrfs_update_inode(trans, root, dir);
out:
C
Chris Mason 已提交
2639 2640 2641
	return ret;
}

2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
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;
}
		

2657 2658 2659
/* 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 已提交
2660
{
2661 2662
	struct extent_buffer *eb;
	int level;
2663
	u64 refs = 1;
2664

2665
	for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
2666 2667
		int ret;

2668 2669 2670 2671 2672 2673 2674 2675 2676
		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;
2677
	}
2678
	return 0;
C
Chris Mason 已提交
2679 2680
}

2681 2682 2683 2684 2685 2686 2687 2688 2689
/*
 * 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)
2690
{
C
Chris Mason 已提交
2691
	struct btrfs_trans_handle *trans;
2692
	struct btrfs_root *root = BTRFS_I(dir)->root;
2693
	struct btrfs_path *path;
2694
	struct btrfs_inode_ref *ref;
2695
	struct btrfs_dir_item *di;
2696
	struct inode *inode = dentry->d_inode;
2697
	u64 index;
2698 2699
	int check_link = 1;
	int err = -ENOSPC;
2700
	int ret;
2701 2702
	u64 ino = btrfs_ino(inode);
	u64 dir_ino = btrfs_ino(dir);
2703

2704 2705 2706 2707 2708 2709 2710 2711 2712 2713
	/*
	 * 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);
2714 2715
	if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
		return trans;
2716

2717
	if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
2718
		return ERR_PTR(-ENOSPC);
2719

2720 2721 2722
	/* check if there is someone else holds reference */
	if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
		return ERR_PTR(-ENOSPC);
2723

2724 2725
	if (atomic_read(&inode->i_count) > 2)
		return ERR_PTR(-ENOSPC);
2726

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

2736 2737
	/* 1 for the orphan item */
	trans = btrfs_start_transaction(root, 1);
2738
	if (IS_ERR(trans)) {
2739 2740 2741 2742
		btrfs_free_path(path);
		root->fs_info->enospc_unlink = 0;
		return trans;
	}
2743

2744 2745
	path->skip_locking = 1;
	path->search_commit_root = 1;
2746

2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
	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;
2758
	}
2759
	btrfs_release_path(path);
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772

	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;
	}
2773
	btrfs_release_path(path);
2774 2775 2776

	if (ret == 0 && S_ISREG(inode->i_mode)) {
		ret = btrfs_lookup_file_extent(trans, root, path,
2777
					       ino, (u64)-1, 0);
2778 2779 2780 2781 2782 2783 2784
		if (ret < 0) {
			err = ret;
			goto out;
		}
		BUG_ON(ret == 0);
		if (check_path_shared(root, path))
			goto out;
2785
		btrfs_release_path(path);
2786 2787 2788 2789 2790 2791 2792
	}

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

2793
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805
				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;
	}
2806
	btrfs_release_path(path);
2807 2808 2809

	ref = btrfs_lookup_inode_ref(trans, root, path,
				dentry->d_name.name, dentry->d_name.len,
2810
				ino, dir_ino, 0);
2811 2812 2813 2814 2815 2816 2817 2818
	if (IS_ERR(ref)) {
		err = PTR_ERR(ref);
		goto out;
	}
	BUG_ON(!ref);
	if (check_path_shared(root, path))
		goto out;
	index = btrfs_inode_ref_index(path->nodes[0], ref);
2819
	btrfs_release_path(path);
2820

2821 2822 2823 2824 2825 2826 2827 2828
	/*
	 * 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.
	 */
2829
	di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841
				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);
2842 2843 2844 2845
	/* Migrate the orphan reservation over */
	if (!err)
		err = btrfs_block_rsv_migrate(trans->block_rsv,
				&root->fs_info->global_block_rsv,
2846
				trans->bytes_reserved);
2847

2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861
	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)
{
	if (trans->block_rsv == &root->fs_info->global_block_rsv) {
2862 2863 2864
		btrfs_block_rsv_release(root, trans->block_rsv,
					trans->bytes_reserved);
		trans->block_rsv = &root->fs_info->trans_block_rsv;
2865 2866 2867
		BUG_ON(!root->fs_info->enospc_unlink);
		root->fs_info->enospc_unlink = 0;
	}
2868
	btrfs_end_transaction(trans, root);
2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881
}

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;
	unsigned long nr = 0;

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

2883 2884
	btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);

2885 2886
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
2887 2888
	if (ret)
		goto out;
2889

2890
	if (inode->i_nlink == 0) {
2891
		ret = btrfs_orphan_add(trans, inode);
2892 2893
		if (ret)
			goto out;
2894
	}
2895

2896
out:
2897
	nr = trans->blocks_used;
2898
	__unlink_end_trans(trans, root);
2899
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2900 2901 2902
	return ret;
}

2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913
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;
2914
	u64 dir_ino = btrfs_ino(dir);
2915 2916 2917 2918 2919

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

2920
	di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
2921
				   name, name_len, -1);
2922
	BUG_ON(IS_ERR_OR_NULL(di));
2923 2924 2925 2926 2927 2928

	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);
	BUG_ON(ret);
2929
	btrfs_release_path(path);
2930 2931 2932

	ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
				 objectid, root->root_key.objectid,
2933
				 dir_ino, &index, name, name_len);
2934 2935
	if (ret < 0) {
		BUG_ON(ret != -ENOENT);
2936
		di = btrfs_search_dir_index_item(root, path, dir_ino,
2937
						 name, name_len);
2938
		BUG_ON(IS_ERR_OR_NULL(di));
2939 2940 2941

		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2942
		btrfs_release_path(path);
2943 2944
		index = key.offset;
	}
2945
	btrfs_release_path(path);
2946

2947
	ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
2948 2949 2950 2951 2952 2953 2954
	BUG_ON(ret);

	btrfs_i_size_write(dir, dir->i_size - name_len * 2);
	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
	ret = btrfs_update_inode(trans, root, dir);
	BUG_ON(ret);

2955
	btrfs_free_path(path);
2956 2957 2958
	return 0;
}

C
Chris Mason 已提交
2959 2960 2961
static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
2962
	int err = 0;
C
Chris Mason 已提交
2963 2964
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
2965
	unsigned long nr = 0;
C
Chris Mason 已提交
2966

2967
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
2968
	    btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
Y
Yan 已提交
2969 2970
		return -ENOTEMPTY;

2971 2972
	trans = __unlink_start_trans(dir, dentry);
	if (IS_ERR(trans))
2973 2974
		return PTR_ERR(trans);

2975
	if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
2976 2977 2978 2979 2980 2981 2982
		err = btrfs_unlink_subvol(trans, root, dir,
					  BTRFS_I(inode)->location.objectid,
					  dentry->d_name.name,
					  dentry->d_name.len);
		goto out;
	}

2983 2984
	err = btrfs_orphan_add(trans, inode);
	if (err)
2985
		goto out;
2986

C
Chris Mason 已提交
2987
	/* now the directory is empty */
2988 2989
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
2990
	if (!err)
2991
		btrfs_i_size_write(inode, 0);
2992
out:
2993
	nr = trans->blocks_used;
2994
	__unlink_end_trans(trans, root);
2995
	btrfs_btree_balance_dirty(root, nr);
2996

C
Chris Mason 已提交
2997 2998 2999 3000 3001 3002
	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
3003
 * any higher than new_size
C
Chris Mason 已提交
3004 3005 3006
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
3007 3008 3009
 *
 * 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 已提交
3010
 */
3011 3012 3013 3014
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 已提交
3015 3016
{
	struct btrfs_path *path;
3017
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3018
	struct btrfs_file_extent_item *fi;
3019 3020
	struct btrfs_key key;
	struct btrfs_key found_key;
C
Chris Mason 已提交
3021
	u64 extent_start = 0;
3022
	u64 extent_num_bytes = 0;
3023
	u64 extent_offset = 0;
C
Chris Mason 已提交
3024
	u64 item_end = 0;
3025 3026
	u64 mask = root->sectorsize - 1;
	u32 found_type = (u8)-1;
C
Chris Mason 已提交
3027 3028
	int found_extent;
	int del_item;
3029 3030
	int pending_del_nr = 0;
	int pending_del_slot = 0;
3031
	int extent_type = -1;
3032 3033
	int ret;
	int err = 0;
3034
	u64 ino = btrfs_ino(inode);
3035 3036

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

3038 3039 3040 3041 3042
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->reada = -1;

3043
	if (root->ref_cows || root == root->fs_info->tree_root)
3044
		btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
3045

3046 3047 3048 3049 3050 3051 3052 3053 3054
	/*
	 * 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);

3055
	key.objectid = ino;
C
Chris Mason 已提交
3056
	key.offset = (u64)-1;
3057 3058
	key.type = (u8)-1;

3059
search_again:
3060
	path->leave_spinning = 1;
3061
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3062 3063 3064 3065
	if (ret < 0) {
		err = ret;
		goto out;
	}
3066

3067
	if (ret > 0) {
3068 3069 3070
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
3071 3072
		if (path->slots[0] == 0)
			goto out;
3073 3074 3075
		path->slots[0]--;
	}

3076
	while (1) {
C
Chris Mason 已提交
3077
		fi = NULL;
3078 3079 3080
		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 已提交
3081

3082
		if (found_key.objectid != ino)
C
Chris Mason 已提交
3083
			break;
3084

3085
		if (found_type < min_type)
C
Chris Mason 已提交
3086 3087
			break;

3088
		item_end = found_key.offset;
C
Chris Mason 已提交
3089
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
3090
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
3091
					    struct btrfs_file_extent_item);
3092 3093
			extent_type = btrfs_file_extent_type(leaf, fi);
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
3094
				item_end +=
3095
				    btrfs_file_extent_num_bytes(leaf, fi);
3096 3097
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
3098
									 fi);
C
Chris Mason 已提交
3099
			}
3100
			item_end--;
C
Chris Mason 已提交
3101
		}
3102 3103 3104 3105
		if (found_type > min_type) {
			del_item = 1;
		} else {
			if (item_end < new_size)
3106
				break;
3107 3108 3109 3110
			if (found_key.offset >= new_size)
				del_item = 1;
			else
				del_item = 0;
C
Chris Mason 已提交
3111 3112 3113
		}
		found_extent = 0;
		/* FIXME, shrink the extent if the ref count is only 1 */
3114 3115 3116 3117
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
3118
			u64 num_dec;
3119
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
3120
			if (!del_item) {
3121 3122
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
3123
				extent_num_bytes = new_size -
3124
					found_key.offset + root->sectorsize - 1;
3125 3126
				extent_num_bytes = extent_num_bytes &
					~((u64)root->sectorsize - 1);
3127 3128 3129
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
3130
					   extent_num_bytes);
3131
				if (root->ref_cows && extent_start != 0)
3132
					inode_sub_bytes(inode, num_dec);
3133
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
3134
			} else {
3135 3136 3137
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
3138 3139 3140
				extent_offset = found_key.offset -
					btrfs_file_extent_offset(leaf, fi);

C
Chris Mason 已提交
3141
				/* FIXME blocksize != 4096 */
3142
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
3143 3144
				if (extent_start != 0) {
					found_extent = 1;
3145
					if (root->ref_cows)
3146
						inode_sub_bytes(inode, num_dec);
3147
				}
C
Chris Mason 已提交
3148
			}
3149
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
3150 3151 3152 3153 3154 3155 3156 3157
			/*
			 * 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) {
3158 3159 3160
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
3161 3162
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
3163 3164 3165
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
3166
				ret = btrfs_truncate_item(trans, root, path,
3167 3168
							  size, 1);
			} else if (root->ref_cows) {
3169 3170
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
3171
			}
C
Chris Mason 已提交
3172
		}
3173
delete:
C
Chris Mason 已提交
3174
		if (del_item) {
3175 3176 3177 3178 3179 3180 3181 3182 3183 3184
			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 {
3185
				BUG();
3186
			}
C
Chris Mason 已提交
3187 3188 3189
		} else {
			break;
		}
3190 3191
		if (found_extent && (root->ref_cows ||
				     root == root->fs_info->tree_root)) {
3192
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
3193
			ret = btrfs_free_extent(trans, root, extent_start,
3194 3195
						extent_num_bytes, 0,
						btrfs_header_owner(leaf),
3196
						ino, extent_offset, 0);
C
Chris Mason 已提交
3197 3198
			BUG_ON(ret);
		}
3199

3200 3201 3202 3203 3204
		if (found_type == BTRFS_INODE_ITEM_KEY)
			break;

		if (path->slots[0] == 0 ||
		    path->slots[0] != pending_del_slot) {
3205 3206 3207
			if (root->ref_cows &&
			    BTRFS_I(inode)->location.objectid !=
						BTRFS_FREE_INO_OBJECTID) {
3208 3209 3210 3211 3212 3213 3214 3215 3216 3217
				err = -EAGAIN;
				goto out;
			}
			if (pending_del_nr) {
				ret = btrfs_del_items(trans, root, path,
						pending_del_slot,
						pending_del_nr);
				BUG_ON(ret);
				pending_del_nr = 0;
			}
3218
			btrfs_release_path(path);
3219
			goto search_again;
3220 3221
		} else {
			path->slots[0]--;
3222
		}
C
Chris Mason 已提交
3223
	}
3224
out:
3225 3226 3227
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
3228
		BUG_ON(ret);
3229
	}
C
Chris Mason 已提交
3230
	btrfs_free_path(path);
3231
	return err;
C
Chris Mason 已提交
3232 3233 3234 3235 3236 3237 3238 3239 3240
}

/*
 * taken from block_truncate_page, but does cow as it zeros out
 * any bytes left in the last page in the file.
 */
static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
{
	struct inode *inode = mapping->host;
3241
	struct btrfs_root *root = BTRFS_I(inode)->root;
3242 3243
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
3244
	struct extent_state *cached_state = NULL;
3245
	char *kaddr;
3246
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
3247 3248 3249
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
3250
	gfp_t mask = btrfs_alloc_write_mask(mapping);
C
Chris Mason 已提交
3251
	int ret = 0;
3252
	u64 page_start;
3253
	u64 page_end;
C
Chris Mason 已提交
3254 3255 3256

	if ((offset & (blocksize - 1)) == 0)
		goto out;
3257
	ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
3258 3259
	if (ret)
		goto out;
C
Chris Mason 已提交
3260 3261

	ret = -ENOMEM;
3262
again:
3263
	page = find_or_create_page(mapping, index, mask);
3264
	if (!page) {
3265
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
3266
		goto out;
3267
	}
3268 3269 3270 3271

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

C
Chris Mason 已提交
3272
	if (!PageUptodate(page)) {
3273
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
3274
		lock_page(page);
3275 3276 3277 3278 3279
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
3280 3281
		if (!PageUptodate(page)) {
			ret = -EIO;
3282
			goto out_unlock;
C
Chris Mason 已提交
3283 3284
		}
	}
3285
	wait_on_page_writeback(page);
3286

3287 3288
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state,
			 GFP_NOFS);
3289 3290 3291 3292
	set_page_extent_mapped(page);

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
3293 3294
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
3295 3296
		unlock_page(page);
		page_cache_release(page);
3297
		btrfs_start_ordered_extent(inode, ordered, 1);
3298 3299 3300 3301
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

3302
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
3303
			  EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
3304
			  0, 0, &cached_state, GFP_NOFS);
3305

3306 3307
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
3308
	if (ret) {
3309 3310
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
3311 3312 3313
		goto out_unlock;
	}

3314 3315 3316 3317 3318 3319 3320
	ret = 0;
	if (offset != PAGE_CACHE_SIZE) {
		kaddr = kmap(page);
		memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
		flush_dcache_page(page);
		kunmap(page);
	}
3321
	ClearPageChecked(page);
3322
	set_page_dirty(page);
3323 3324
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
			     GFP_NOFS);
C
Chris Mason 已提交
3325

3326
out_unlock:
3327
	if (ret)
3328
		btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
3329 3330 3331 3332 3333 3334
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

3335 3336 3337 3338 3339 3340
/*
 * 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
 */
3341
int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
C
Chris Mason 已提交
3342
{
3343 3344 3345
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3346
	struct extent_map *em = NULL;
3347
	struct extent_state *cached_state = NULL;
3348
	u64 mask = root->sectorsize - 1;
3349
	u64 hole_start = (oldsize + mask) & ~mask;
3350 3351 3352 3353
	u64 block_end = (size + mask) & ~mask;
	u64 last_byte;
	u64 cur_offset;
	u64 hole_size;
3354
	int err = 0;
C
Chris Mason 已提交
3355

3356 3357 3358 3359 3360 3361 3362
	if (size <= hole_start)
		return 0;

	while (1) {
		struct btrfs_ordered_extent *ordered;
		btrfs_wait_ordered_range(inode, hole_start,
					 block_end - hole_start);
3363 3364
		lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
				 &cached_state, GFP_NOFS);
3365 3366 3367
		ordered = btrfs_lookup_ordered_extent(inode, hole_start);
		if (!ordered)
			break;
3368 3369
		unlock_extent_cached(io_tree, hole_start, block_end - 1,
				     &cached_state, GFP_NOFS);
3370 3371
		btrfs_put_ordered_extent(ordered);
	}
C
Chris Mason 已提交
3372

3373 3374 3375 3376
	cur_offset = hole_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				block_end - cur_offset, 0);
3377
		BUG_ON(IS_ERR_OR_NULL(em));
3378 3379
		last_byte = min(extent_map_end(em), block_end);
		last_byte = (last_byte + mask) & ~mask;
3380
		if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
3381
			u64 hint_byte = 0;
3382
			hole_size = last_byte - cur_offset;
3383

3384
			trans = btrfs_start_transaction(root, 3);
3385 3386
			if (IS_ERR(trans)) {
				err = PTR_ERR(trans);
3387
				break;
3388
			}
3389 3390 3391 3392

			err = btrfs_drop_extents(trans, inode, cur_offset,
						 cur_offset + hole_size,
						 &hint_byte, 1);
3393
			if (err) {
3394
				btrfs_update_inode(trans, root, inode);
3395
				btrfs_end_transaction(trans, root);
3396
				break;
3397
			}
3398

3399
			err = btrfs_insert_file_extent(trans, root,
3400
					btrfs_ino(inode), cur_offset, 0,
3401 3402
					0, hole_size, 0, hole_size,
					0, 0, 0);
3403
			if (err) {
3404
				btrfs_update_inode(trans, root, inode);
3405
				btrfs_end_transaction(trans, root);
3406
				break;
3407
			}
3408

3409 3410
			btrfs_drop_extent_cache(inode, hole_start,
					last_byte - 1, 0);
3411

3412
			btrfs_update_inode(trans, root, inode);
3413
			btrfs_end_transaction(trans, root);
3414 3415
		}
		free_extent_map(em);
3416
		em = NULL;
3417
		cur_offset = last_byte;
3418
		if (cur_offset >= block_end)
3419 3420
			break;
	}
3421

3422
	free_extent_map(em);
3423 3424
	unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
			     GFP_NOFS);
3425 3426
	return err;
}
C
Chris Mason 已提交
3427

3428
static int btrfs_setsize(struct inode *inode, loff_t newsize)
3429
{
3430 3431
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
3432
	loff_t oldsize = i_size_read(inode);
3433 3434
	int ret;

3435
	if (newsize == oldsize)
3436 3437
		return 0;

3438 3439 3440
	if (newsize > oldsize) {
		truncate_pagecache(inode, oldsize, newsize);
		ret = btrfs_cont_expand(inode, oldsize, newsize);
3441
		if (ret)
3442 3443
			return ret;

3444 3445 3446 3447 3448 3449 3450
		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);
3451
		btrfs_end_transaction(trans, root);
3452
	} else {
3453

3454 3455 3456 3457 3458 3459 3460
		/*
		 * 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)
			BTRFS_I(inode)->ordered_data_close = 1;
3461

3462 3463 3464
		/* we don't support swapfiles, so vmtruncate shouldn't fail */
		truncate_setsize(inode, newsize);
		ret = btrfs_truncate(inode);
3465 3466
	}

3467
	return ret;
3468 3469
}

3470 3471 3472
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
3473
	struct btrfs_root *root = BTRFS_I(inode)->root;
3474
	int err;
C
Chris Mason 已提交
3475

3476 3477 3478
	if (btrfs_root_readonly(root))
		return -EROFS;

3479 3480 3481
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
3482

3483
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
3484
		err = btrfs_setsize(inode, attr->ia_size);
3485 3486
		if (err)
			return err;
C
Chris Mason 已提交
3487
	}
3488

C
Christoph Hellwig 已提交
3489 3490
	if (attr->ia_valid) {
		setattr_copy(inode, attr);
3491
		err = btrfs_dirty_inode(inode);
C
Christoph Hellwig 已提交
3492

3493
		if (!err && attr->ia_valid & ATTR_MODE)
C
Christoph Hellwig 已提交
3494 3495
			err = btrfs_acl_chmod(inode);
	}
J
Josef Bacik 已提交
3496

C
Chris Mason 已提交
3497 3498
	return err;
}
3499

3500
void btrfs_evict_inode(struct inode *inode)
C
Chris Mason 已提交
3501 3502 3503
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
3504
	struct btrfs_block_rsv *rsv, *global_rsv;
3505
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
3506
	unsigned long nr;
C
Chris Mason 已提交
3507 3508
	int ret;

3509 3510
	trace_btrfs_inode_evict(inode);

C
Chris Mason 已提交
3511
	truncate_inode_pages(&inode->i_data, 0);
3512
	if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
3513
			       btrfs_is_free_space_inode(root, inode)))
3514 3515
		goto no_delete;

C
Chris Mason 已提交
3516
	if (is_bad_inode(inode)) {
3517
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
3518 3519
		goto no_delete;
	}
3520
	/* do we really want it for ->i_nlink > 0 and zero btrfs_root_refs? */
C
Chris Mason 已提交
3521
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
3522

3523 3524 3525 3526 3527
	if (root->fs_info->log_root_recovering) {
		BUG_ON(!list_empty(&BTRFS_I(inode)->i_orphan));
		goto no_delete;
	}

3528 3529 3530 3531 3532
	if (inode->i_nlink > 0) {
		BUG_ON(btrfs_root_refs(&root->root_item) != 0);
		goto no_delete;
	}

3533 3534 3535 3536 3537
	rsv = btrfs_alloc_block_rsv(root);
	if (!rsv) {
		btrfs_orphan_del(NULL, inode);
		goto no_delete;
	}
3538
	rsv->size = min_size;
3539
	global_rsv = &root->fs_info->global_block_rsv;
3540

3541
	btrfs_i_size_write(inode, 0);
3542

3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
	/*
	 * This is a bit simpler than btrfs_truncate since
	 *
	 * 1) We've already reserved our space for our orphan item in the
	 *    unlink.
	 * 2) We're going to delete the inode item, so we don't need to update
	 *    it at all.
	 *
	 * So we just need to reserve some slack space in case we add bytes when
	 * doing the truncate.
	 */
3554
	while (1) {
3555
		ret = btrfs_block_rsv_refill_noflush(root, rsv, min_size);
3556 3557 3558 3559 3560 3561 3562 3563

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

		if (ret) {
3566
			printk(KERN_WARNING "Could not get space for a "
3567
			       "delete, will truncate on mount %d\n", ret);
3568 3569 3570
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
3571
		}
3572

3573 3574 3575 3576 3577
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans)) {
			btrfs_orphan_del(NULL, inode);
			btrfs_free_block_rsv(root, rsv);
			goto no_delete;
3578
		}
3579

3580 3581
		trans->block_rsv = rsv;

3582
		ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
3583 3584
		if (ret != -EAGAIN)
			break;
3585

3586 3587 3588 3589 3590
		nr = trans->blocks_used;
		btrfs_end_transaction(trans, root);
		trans = NULL;
		btrfs_btree_balance_dirty(root, nr);
	}
3591

3592 3593
	btrfs_free_block_rsv(root, rsv);

3594
	if (ret == 0) {
3595
		trans->block_rsv = root->orphan_block_rsv;
3596 3597 3598
		ret = btrfs_orphan_del(trans, inode);
		BUG_ON(ret);
	}
3599

3600
	trans->block_rsv = &root->fs_info->trans_block_rsv;
3601 3602
	if (!(root == root->fs_info->tree_root ||
	      root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
3603
		btrfs_return_ino(root, btrfs_ino(inode));
3604

3605
	nr = trans->blocks_used;
3606
	btrfs_end_transaction(trans, root);
3607
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3608
no_delete:
3609
	end_writeback(inode);
3610
	return;
C
Chris Mason 已提交
3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
}

/*
 * 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;
3625
	int ret = 0;
C
Chris Mason 已提交
3626 3627

	path = btrfs_alloc_path();
3628 3629
	if (!path)
		return -ENOMEM;
3630

3631
	di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
C
Chris Mason 已提交
3632
				    namelen, 0);
3633 3634
	if (IS_ERR(di))
		ret = PTR_ERR(di);
3635

3636
	if (IS_ERR_OR_NULL(di))
3637
		goto out_err;
3638

3639
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
3640 3641 3642
out:
	btrfs_free_path(path);
	return ret;
3643 3644 3645
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
3646 3647 3648 3649 3650 3651 3652 3653
}

/*
 * 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,
3654 3655 3656 3657
				    struct inode *dir,
				    struct dentry *dentry,
				    struct btrfs_key *location,
				    struct btrfs_root **sub_root)
C
Chris Mason 已提交
3658
{
3659 3660 3661 3662 3663 3664
	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 已提交
3665

3666 3667 3668 3669 3670
	path = btrfs_alloc_path();
	if (!path) {
		err = -ENOMEM;
		goto out;
	}
C
Chris Mason 已提交
3671

3672 3673 3674 3675 3676 3677 3678 3679 3680
	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 已提交
3681

3682 3683
	leaf = path->nodes[0];
	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
3684
	if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
3685 3686
	    btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
		goto out;
C
Chris Mason 已提交
3687

3688 3689 3690 3691 3692 3693
	ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
				   (unsigned long)(ref + 1),
				   dentry->d_name.len);
	if (ret)
		goto out;

3694
	btrfs_release_path(path);
3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714

	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 已提交
3715 3716
}

3717 3718 3719 3720
static void inode_tree_add(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_inode *entry;
3721 3722
	struct rb_node **p;
	struct rb_node *parent;
3723
	u64 ino = btrfs_ino(inode);
3724 3725 3726
again:
	p = &root->inode_tree.rb_node;
	parent = NULL;
3727

A
Al Viro 已提交
3728
	if (inode_unhashed(inode))
3729 3730
		return;

3731 3732 3733 3734 3735
	spin_lock(&root->inode_lock);
	while (*p) {
		parent = *p;
		entry = rb_entry(parent, struct btrfs_inode, rb_node);

3736
		if (ino < btrfs_ino(&entry->vfs_inode))
3737
			p = &parent->rb_left;
3738
		else if (ino > btrfs_ino(&entry->vfs_inode))
3739
			p = &parent->rb_right;
3740 3741
		else {
			WARN_ON(!(entry->vfs_inode.i_state &
3742
				  (I_WILL_FREE | I_FREEING)));
3743 3744 3745 3746
			rb_erase(parent, &root->inode_tree);
			RB_CLEAR_NODE(parent);
			spin_unlock(&root->inode_lock);
			goto again;
3747 3748 3749 3750 3751 3752 3753 3754 3755 3756
		}
	}
	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;
3757
	int empty = 0;
3758

3759
	spin_lock(&root->inode_lock);
3760 3761 3762
	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);
3763
		empty = RB_EMPTY_ROOT(&root->inode_tree);
3764
	}
3765
	spin_unlock(&root->inode_lock);
3766

3767 3768 3769 3770 3771 3772 3773 3774
	/*
	 * 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) {
3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801
		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);
	}
}

int btrfs_invalidate_inodes(struct btrfs_root *root)
{
	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);

3802
		if (objectid < btrfs_ino(&entry->vfs_inode))
3803
			node = node->rb_left;
3804
		else if (objectid > btrfs_ino(&entry->vfs_inode))
3805 3806 3807 3808 3809 3810 3811
			node = node->rb_right;
		else
			break;
	}
	if (!node) {
		while (prev) {
			entry = rb_entry(prev, struct btrfs_inode, rb_node);
3812
			if (objectid <= btrfs_ino(&entry->vfs_inode)) {
3813 3814 3815 3816 3817 3818 3819 3820
				node = prev;
				break;
			}
			prev = rb_next(prev);
		}
	}
	while (node) {
		entry = rb_entry(node, struct btrfs_inode, rb_node);
3821
		objectid = btrfs_ino(&entry->vfs_inode) + 1;
3822 3823 3824 3825 3826 3827
		inode = igrab(&entry->vfs_inode);
		if (inode) {
			spin_unlock(&root->inode_lock);
			if (atomic_read(&inode->i_count) > 1)
				d_prune_aliases(inode);
			/*
3828
			 * btrfs_drop_inode will have it removed from
3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844
			 * 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);
	return 0;
3845 3846
}

3847 3848 3849 3850 3851
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;
3852
	btrfs_set_inode_space_info(args->root, inode);
C
Chris Mason 已提交
3853 3854 3855 3856 3857 3858
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
3859
	return args->ino == btrfs_ino(inode) &&
3860
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
3861 3862
}

3863 3864 3865
static struct inode *btrfs_iget_locked(struct super_block *s,
				       u64 objectid,
				       struct btrfs_root *root)
C
Chris Mason 已提交
3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
{
	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 已提交
3878 3879 3880 3881
/* 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,
3882
			 struct btrfs_root *root, int *new)
B
Balaji Rao 已提交
3883 3884 3885 3886 3887
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
3888
		return ERR_PTR(-ENOMEM);
B
Balaji Rao 已提交
3889 3890 3891 3892 3893

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
3894 3895 3896 3897 3898 3899
		if (!is_bad_inode(inode)) {
			inode_tree_add(inode);
			unlock_new_inode(inode);
			if (new)
				*new = 1;
		} else {
3900 3901 3902
			unlock_new_inode(inode);
			iput(inode);
			inode = ERR_PTR(-ESTALE);
3903 3904 3905
		}
	}

B
Balaji Rao 已提交
3906 3907 3908
	return inode;
}

3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930
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));
	BTRFS_I(inode)->dummy_inode = 1;

	inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
	inode->i_op = &simple_dir_inode_operations;
	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;
}

3931
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
3932
{
3933
	struct inode *inode;
3934
	struct btrfs_root *root = BTRFS_I(dir)->root;
C
Chris Mason 已提交
3935 3936
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
3937
	int index;
3938
	int ret = 0;
C
Chris Mason 已提交
3939 3940 3941

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

3943 3944 3945 3946
	if (unlikely(d_need_lookup(dentry))) {
		memcpy(&location, dentry->d_fsdata, sizeof(struct btrfs_key));
		kfree(dentry->d_fsdata);
		dentry->d_fsdata = NULL;
3947 3948
		/* This thing is hashed, drop it for now */
		d_drop(dentry);
3949 3950 3951
	} else {
		ret = btrfs_inode_by_name(dir, dentry, &location);
	}
3952

C
Chris Mason 已提交
3953 3954
	if (ret < 0)
		return ERR_PTR(ret);
3955

3956 3957 3958 3959
	if (location.objectid == 0)
		return NULL;

	if (location.type == BTRFS_INODE_ITEM_KEY) {
3960
		inode = btrfs_iget(dir->i_sb, &location, root, NULL);
3961 3962 3963 3964 3965
		return inode;
	}

	BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);

3966
	index = srcu_read_lock(&root->fs_info->subvol_srcu);
3967 3968 3969 3970 3971 3972 3973 3974
	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 {
3975
		inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
C
Chris Mason 已提交
3976
	}
3977 3978
	srcu_read_unlock(&root->fs_info->subvol_srcu, index);

3979
	if (!IS_ERR(inode) && root != sub_root) {
3980 3981
		down_read(&root->fs_info->cleanup_work_sem);
		if (!(inode->i_sb->s_flags & MS_RDONLY))
3982
			ret = btrfs_orphan_cleanup(sub_root);
3983
		up_read(&root->fs_info->cleanup_work_sem);
3984 3985
		if (ret)
			inode = ERR_PTR(ret);
3986 3987
	}

3988 3989 3990
	return inode;
}

3991
static int btrfs_dentry_delete(const struct dentry *dentry)
3992 3993 3994
{
	struct btrfs_root *root;

3995 3996
	if (!dentry->d_inode && !IS_ROOT(dentry))
		dentry = dentry->d_parent;
3997

3998 3999 4000 4001 4002
	if (dentry->d_inode) {
		root = BTRFS_I(dentry->d_inode)->root;
		if (btrfs_root_refs(&root->root_item) == 0)
			return 1;
	}
4003 4004 4005
	return 0;
}

4006 4007 4008 4009 4010 4011
static void btrfs_dentry_release(struct dentry *dentry)
{
	if (dentry->d_fsdata)
		kfree(dentry->d_fsdata);
}

4012 4013 4014
static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
				   struct nameidata *nd)
{
4015 4016 4017 4018 4019 4020 4021 4022 4023
	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 已提交
4024 4025
}

4026
unsigned char btrfs_filetype_table[] = {
C
Chris Mason 已提交
4027 4028 4029
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

4030 4031
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
4032
{
4033
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
4034 4035 4036 4037
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
4038
	struct btrfs_key found_key;
C
Chris Mason 已提交
4039
	struct btrfs_path *path;
4040 4041
	struct list_head ins_list;
	struct list_head del_list;
4042
	struct qstr q;
C
Chris Mason 已提交
4043
	int ret;
4044
	struct extent_buffer *leaf;
C
Chris Mason 已提交
4045 4046 4047 4048 4049 4050 4051
	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;
4052 4053 4054
	char tmp_name[32];
	char *name_ptr;
	int name_len;
4055
	int is_curr = 0;	/* filp->f_pos points to the current index? */
C
Chris Mason 已提交
4056 4057 4058 4059

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

4061 4062
	/* special case for "." */
	if (filp->f_pos == 0) {
4063 4064
		over = filldir(dirent, ".", 1,
			       filp->f_pos, btrfs_ino(inode), DT_DIR);
4065 4066 4067 4068 4069 4070
		if (over)
			return 0;
		filp->f_pos = 1;
	}
	/* special case for .., just use the back ref */
	if (filp->f_pos == 1) {
4071
		u64 pino = parent_ino(filp->f_path.dentry);
4072
		over = filldir(dirent, "..", 2,
4073
			       filp->f_pos, pino, DT_DIR);
4074
		if (over)
4075
			return 0;
4076 4077
		filp->f_pos = 2;
	}
4078
	path = btrfs_alloc_path();
4079 4080
	if (!path)
		return -ENOMEM;
C
Chris Mason 已提交
4081

4082
	path->reada = 1;
4083

4084 4085 4086 4087 4088 4089
	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 已提交
4090 4091
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
4092
	key.objectid = btrfs_ino(inode);
4093

C
Chris Mason 已提交
4094 4095 4096
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
4097 4098

	while (1) {
4099
		leaf = path->nodes[0];
C
Chris Mason 已提交
4100
		slot = path->slots[0];
4101 4102 4103 4104 4105 4106 4107
		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 已提交
4108
		}
4109

4110 4111 4112 4113
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
4114
			break;
4115
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
4116
			break;
4117
		if (found_key.offset < filp->f_pos)
4118
			goto next;
4119 4120 4121 4122
		if (key_type == BTRFS_DIR_INDEX_KEY &&
		    btrfs_should_delete_dir_index(&del_list,
						  found_key.offset))
			goto next;
4123 4124

		filp->f_pos = found_key.offset;
4125
		is_curr = 1;
4126

C
Chris Mason 已提交
4127 4128
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
4129
		di_total = btrfs_item_size(leaf, item);
4130 4131

		while (di_cur < di_total) {
4132
			struct btrfs_key location;
4133
			struct dentry *tmp;
4134

4135 4136 4137
			if (verify_dir_item(root, leaf, di))
				break;

4138
			name_len = btrfs_dir_name_len(leaf, di);
4139
			if (name_len <= sizeof(tmp_name)) {
4140 4141 4142
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
4143 4144 4145 4146
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
4147 4148 4149 4150 4151 4152
			}
			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);
4153

4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180
			q.name = name_ptr;
			q.len = name_len;
			q.hash = full_name_hash(q.name, q.len);
			tmp = d_lookup(filp->f_dentry, &q);
			if (!tmp) {
				struct btrfs_key *newkey;

				newkey = kzalloc(sizeof(struct btrfs_key),
						 GFP_NOFS);
				if (!newkey)
					goto no_dentry;
				tmp = d_alloc(filp->f_dentry, &q);
				if (!tmp) {
					kfree(newkey);
					dput(tmp);
					goto no_dentry;
				}
				memcpy(newkey, &location,
				       sizeof(struct btrfs_key));
				tmp->d_fsdata = newkey;
				tmp->d_flags |= DCACHE_NEED_LOOKUP;
				d_rehash(tmp);
				dput(tmp);
			} else {
				dput(tmp);
			}
no_dentry:
4181 4182 4183 4184 4185 4186 4187 4188
			/* is this a reference to our own snapshot? If so
			 * skip it
			 */
			if (location.type == BTRFS_ROOT_ITEM_KEY &&
			    location.objectid == root->root_key.objectid) {
				over = 0;
				goto skip;
			}
4189
			over = filldir(dirent, name_ptr, name_len,
4190
				       found_key.offset, location.objectid,
C
Chris Mason 已提交
4191
				       d_type);
4192

4193
skip:
4194 4195 4196
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
4197 4198
			if (over)
				goto nopos;
J
Josef Bacik 已提交
4199
			di_len = btrfs_dir_name_len(leaf, di) +
4200
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
4201 4202 4203
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
4204 4205
next:
		path->slots[0]++;
C
Chris Mason 已提交
4206
	}
4207

4208 4209 4210 4211 4212 4213 4214 4215 4216
	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;
	}

4217
	/* Reached end of directory/root. Bump pos past the last item. */
4218
	if (key_type == BTRFS_DIR_INDEX_KEY)
4219 4220 4221 4222 4223
		/*
		 * 32-bit glibc will use getdents64, but then strtol -
		 * so the last number we can serve is this.
		 */
		filp->f_pos = 0x7fffffff;
4224 4225
	else
		filp->f_pos++;
C
Chris Mason 已提交
4226 4227 4228
nopos:
	ret = 0;
err:
4229 4230
	if (key_type == BTRFS_DIR_INDEX_KEY)
		btrfs_put_delayed_items(&ins_list, &del_list);
C
Chris Mason 已提交
4231 4232 4233 4234
	btrfs_free_path(path);
	return ret;
}

4235
int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
C
Chris Mason 已提交
4236 4237 4238 4239
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;
4240
	bool nolock = false;
C
Chris Mason 已提交
4241

4242
	if (BTRFS_I(inode)->dummy_inode)
4243 4244
		return 0;

4245
	if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(root, inode))
4246
		nolock = true;
4247

4248
	if (wbc->sync_mode == WB_SYNC_ALL) {
4249
		if (nolock)
4250
			trans = btrfs_join_transaction_nolock(root);
4251
		else
4252
			trans = btrfs_join_transaction(root);
4253 4254
		if (IS_ERR(trans))
			return PTR_ERR(trans);
4255 4256 4257 4258
		if (nolock)
			ret = btrfs_end_transaction_nolock(trans, root);
		else
			ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
4259 4260 4261 4262 4263
	}
	return ret;
}

/*
4264
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
4265 4266 4267 4268
 * 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.
 */
4269
int btrfs_dirty_inode(struct inode *inode)
C
Chris Mason 已提交
4270 4271 4272
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
4273 4274 4275
	int ret;

	if (BTRFS_I(inode)->dummy_inode)
4276
		return 0;
C
Chris Mason 已提交
4277

4278
	trans = btrfs_join_transaction(root);
4279 4280
	if (IS_ERR(trans))
		return PTR_ERR(trans);
4281 4282

	ret = btrfs_update_inode(trans, root, inode);
4283 4284 4285 4286
	if (ret && ret == -ENOSPC) {
		/* whoops, lets try again with the full transaction */
		btrfs_end_transaction(trans, root);
		trans = btrfs_start_transaction(root, 1);
4287 4288
		if (IS_ERR(trans))
			return PTR_ERR(trans);
4289

4290 4291
		ret = btrfs_update_inode(trans, root, inode);
	}
C
Chris Mason 已提交
4292
	btrfs_end_transaction(trans, root);
4293 4294
	if (BTRFS_I(inode)->delayed_node)
		btrfs_balance_delayed_items(root);
4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342

	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.
 */
int btrfs_update_time(struct file *file)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct timespec now;
	int ret;
	enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;

	/* First try to exhaust all avenues to not sync */
	if (IS_NOCMTIME(inode))
		return 0;

	now = current_fs_time(inode->i_sb);
	if (!timespec_equal(&inode->i_mtime, &now))
		sync_it = S_MTIME;

	if (!timespec_equal(&inode->i_ctime, &now))
		sync_it |= S_CTIME;

	if (IS_I_VERSION(inode))
		sync_it |= S_VERSION;

	if (!sync_it)
		return 0;

	/* Finally allowed to write? Takes lock. */
	if (mnt_want_write_file(file))
		return 0;

	/* Only change inode inside the lock region */
	if (sync_it & S_VERSION)
		inode_inc_iversion(inode);
	if (sync_it & S_CTIME)
		inode->i_ctime = now;
	if (sync_it & S_MTIME)
		inode->i_mtime = now;
	ret = btrfs_dirty_inode(inode);
	if (!ret)
		mark_inode_dirty_sync(inode);
	mnt_drop_write(file->f_path.mnt);
	return ret;
C
Chris Mason 已提交
4343 4344
}

4345 4346 4347 4348 4349
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
4350 4351 4352 4353 4354 4355 4356 4357
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;

4358
	key.objectid = btrfs_ino(inode);
4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
	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]);

4390
	if (found_key.objectid != btrfs_ino(inode) ||
4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401
	    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;
}

4402 4403 4404 4405
/*
 * 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
 */
4406
int btrfs_set_inode_index(struct inode *dir, u64 *index)
4407 4408 4409 4410
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
4411 4412 4413 4414 4415 4416
		ret = btrfs_inode_delayed_dir_index_count(dir);
		if (ret) {
			ret = btrfs_set_inode_index_count(dir);
			if (ret)
				return ret;
		}
4417 4418
	}

4419
	*index = BTRFS_I(dir)->index_cnt;
4420 4421 4422 4423 4424
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
4425 4426
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
4427
				     struct inode *dir,
4428
				     const char *name, int name_len,
4429 4430
				     u64 ref_objectid, u64 objectid,
				     umode_t mode, u64 *index)
C
Chris Mason 已提交
4431 4432
{
	struct inode *inode;
4433
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
4434
	struct btrfs_key *location;
4435
	struct btrfs_path *path;
4436 4437 4438 4439
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
4440 4441 4442
	int ret;
	int owner;

4443
	path = btrfs_alloc_path();
4444 4445
	if (!path)
		return ERR_PTR(-ENOMEM);
4446

C
Chris Mason 已提交
4447
	inode = new_inode(root->fs_info->sb);
4448 4449
	if (!inode) {
		btrfs_free_path(path);
C
Chris Mason 已提交
4450
		return ERR_PTR(-ENOMEM);
4451
	}
C
Chris Mason 已提交
4452

4453 4454 4455 4456 4457 4458
	/*
	 * we have to initialize this early, so we can reclaim the inode
	 * number if we fail afterwards in this function.
	 */
	inode->i_ino = objectid;

4459
	if (dir) {
4460 4461
		trace_btrfs_inode_request(dir);

4462
		ret = btrfs_set_inode_index(dir, index);
4463
		if (ret) {
4464
			btrfs_free_path(path);
4465
			iput(inode);
4466
			return ERR_PTR(ret);
4467
		}
4468 4469 4470 4471 4472 4473 4474
	}
	/*
	 * 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 已提交
4475
	BTRFS_I(inode)->root = root;
4476
	BTRFS_I(inode)->generation = trans->transid;
4477
	inode->i_generation = BTRFS_I(inode)->generation;
4478
	btrfs_set_inode_space_info(root, inode);
4479

4480
	if (S_ISDIR(mode))
C
Chris Mason 已提交
4481 4482 4483
		owner = 0;
	else
		owner = 1;
4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495

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

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

4496
	path->leave_spinning = 1;
4497 4498
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
4499 4500
		goto fail;

4501
	inode_init_owner(inode, dir, mode);
4502
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
4503
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
4504 4505
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
4506
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
4507 4508 4509 4510

	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);
4511
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
4512 4513 4514
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

4515 4516 4517
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
4518 4519 4520 4521 4522
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

4523 4524
	btrfs_inherit_iflags(inode, dir);

4525
	if (S_ISREG(mode)) {
4526 4527
		if (btrfs_test_opt(root, NODATASUM))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
4528 4529
		if (btrfs_test_opt(root, NODATACOW) ||
		    (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
4530 4531 4532
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
	}

C
Chris Mason 已提交
4533
	insert_inode_hash(inode);
4534
	inode_tree_add(inode);
4535 4536

	trace_btrfs_inode_new(inode);
4537
	btrfs_set_inode_last_trans(trans, inode);
4538

C
Chris Mason 已提交
4539
	return inode;
4540
fail:
4541 4542
	if (dir)
		BTRFS_I(dir)->index_cnt--;
4543
	btrfs_free_path(path);
4544
	iput(inode);
4545
	return ERR_PTR(ret);
C
Chris Mason 已提交
4546 4547 4548 4549 4550 4551 4552
}

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

4553 4554 4555 4556 4557 4558
/*
 * 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.
 */
4559 4560 4561
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 已提交
4562
{
4563
	int ret = 0;
C
Chris Mason 已提交
4564
	struct btrfs_key key;
4565
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
4566 4567
	u64 ino = btrfs_ino(inode);
	u64 parent_ino = btrfs_ino(parent_inode);
4568

4569
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
4570 4571
		memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
	} else {
4572
		key.objectid = ino;
4573 4574 4575 4576
		btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
		key.offset = 0;
	}

4577
	if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
4578 4579
		ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
					 key.objectid, root->root_key.objectid,
4580
					 parent_ino, index, name, name_len);
4581
	} else if (add_backref) {
4582 4583
		ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
					     parent_ino, index);
4584
	}
C
Chris Mason 已提交
4585 4586

	if (ret == 0) {
4587
		ret = btrfs_insert_dir_item(trans, root, name, name_len,
4588
					    parent_inode, &key,
4589
					    btrfs_inode_type(inode), index);
4590 4591
		if (ret)
			goto fail_dir_item;
4592

4593
		btrfs_i_size_write(parent_inode, parent_inode->i_size +
4594
				   name_len * 2);
4595
		parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
4596
		ret = btrfs_update_inode(trans, root, parent_inode);
C
Chris Mason 已提交
4597 4598
	}
	return ret;
4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615

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 已提交
4616 4617 4618
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
4619 4620
			    struct inode *dir, struct dentry *dentry,
			    struct inode *inode, int backref, u64 index)
C
Chris Mason 已提交
4621
{
4622 4623 4624
	int err = btrfs_add_link(trans, dir, inode,
				 dentry->d_name.name, dentry->d_name.len,
				 backref, index);
C
Chris Mason 已提交
4625 4626 4627 4628 4629
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
4630
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
4631
			umode_t mode, dev_t rdev)
J
Josef Bacik 已提交
4632 4633 4634
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
4635
	struct inode *inode = NULL;
J
Josef Bacik 已提交
4636 4637 4638
	int err;
	int drop_inode = 0;
	u64 objectid;
4639
	unsigned long nr = 0;
4640
	u64 index = 0;
J
Josef Bacik 已提交
4641 4642 4643 4644

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

4645 4646 4647 4648 4649
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
4650 4651 4652
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
4653

4654 4655 4656 4657
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

4658
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4659
				dentry->d_name.len, btrfs_ino(dir), objectid,
4660
				mode, &index);
4661 4662
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
J
Josef Bacik 已提交
4663
		goto out_unlock;
4664
	}
J
Josef Bacik 已提交
4665

4666
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
4667 4668 4669 4670 4671
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

4672 4673 4674 4675 4676 4677 4678 4679
	/*
	* 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;
4680
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
J
Josef Bacik 已提交
4681 4682 4683 4684
	if (err)
		drop_inode = 1;
	else {
		init_special_inode(inode, inode->i_mode, rdev);
4685
		btrfs_update_inode(trans, root, inode);
4686
		d_instantiate(dentry, inode);
J
Josef Bacik 已提交
4687 4688
	}
out_unlock:
4689
	nr = trans->blocks_used;
4690
	btrfs_end_transaction(trans, root);
4691
	btrfs_btree_balance_dirty(root, nr);
J
Josef Bacik 已提交
4692 4693 4694 4695 4696 4697 4698
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
	return err;
}

C
Chris Mason 已提交
4699
static int btrfs_create(struct inode *dir, struct dentry *dentry,
A
Al Viro 已提交
4700
			umode_t mode, struct nameidata *nd)
C
Chris Mason 已提交
4701 4702 4703
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
4704
	struct inode *inode = NULL;
C
Chris Mason 已提交
4705
	int drop_inode = 0;
4706
	int err;
4707
	unsigned long nr = 0;
C
Chris Mason 已提交
4708
	u64 objectid;
4709
	u64 index = 0;
C
Chris Mason 已提交
4710

4711 4712 4713 4714 4715
	/*
	 * 2 for inode item and ref
	 * 2 for dir items
	 * 1 for xattr if selinux is on
	 */
4716 4717 4718
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
4719

4720 4721 4722 4723
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

4724
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4725
				dentry->d_name.len, btrfs_ino(dir), objectid,
4726
				mode, &index);
4727 4728
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
4729
		goto out_unlock;
4730
	}
C
Chris Mason 已提交
4731

4732
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
4733 4734 4735 4736 4737
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

4738 4739 4740 4741 4742 4743 4744 4745 4746
	/*
	* 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;

4747
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
4748 4749 4750 4751
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
4752
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
4753
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
4754
		d_instantiate(dentry, inode);
C
Chris Mason 已提交
4755 4756
	}
out_unlock:
4757
	nr = trans->blocks_used;
4758
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
4759 4760 4761 4762
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
4763
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4764 4765 4766 4767 4768 4769 4770 4771 4772
	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;
4773
	u64 index;
4774
	unsigned long nr = 0;
C
Chris Mason 已提交
4775 4776 4777
	int err;
	int drop_inode = 0;

4778 4779
	/* do not allow sys_link's with other subvols of the same device */
	if (root->objectid != BTRFS_I(inode)->root->objectid)
4780
		return -EXDEV;
4781

4782 4783
	if (inode->i_nlink == ~0U)
		return -EMLINK;
4784

4785
	err = btrfs_set_inode_index(dir, &index);
4786 4787 4788
	if (err)
		goto fail;

4789
	/*
4790
	 * 2 items for inode and inode ref
4791
	 * 2 items for dir items
4792
	 * 1 item for parent inode
4793
	 */
4794
	trans = btrfs_start_transaction(root, 5);
4795 4796 4797 4798
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto fail;
	}
4799

4800 4801
	btrfs_inc_nlink(inode);
	inode->i_ctime = CURRENT_TIME;
A
Al Viro 已提交
4802
	ihold(inode);
4803

4804
	err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
4805

4806
	if (err) {
4807
		drop_inode = 1;
4808
	} else {
4809
		struct dentry *parent = dentry->d_parent;
4810 4811
		err = btrfs_update_inode(trans, root, inode);
		BUG_ON(err);
4812
		d_instantiate(dentry, inode);
4813
		btrfs_log_new_name(trans, inode, NULL, parent);
4814
	}
C
Chris Mason 已提交
4815

4816
	nr = trans->blocks_used;
4817
	btrfs_end_transaction(trans, root);
4818
fail:
C
Chris Mason 已提交
4819 4820 4821 4822
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
4823
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4824 4825 4826
	return err;
}

4827
static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
C
Chris Mason 已提交
4828
{
4829
	struct inode *inode = NULL;
C
Chris Mason 已提交
4830 4831 4832 4833
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
4834
	u64 objectid = 0;
4835
	u64 index = 0;
4836
	unsigned long nr = 1;
C
Chris Mason 已提交
4837

4838 4839 4840 4841 4842
	/*
	 * 2 items for inode and ref
	 * 2 items for dir items
	 * 1 for xattr if selinux is on
	 */
4843 4844 4845
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
4846

4847 4848 4849 4850
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_fail;

4851
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4852
				dentry->d_name.len, btrfs_ino(dir), objectid,
4853
				S_IFDIR | mode, &index);
C
Chris Mason 已提交
4854 4855 4856 4857
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
4858

C
Chris Mason 已提交
4859
	drop_on_err = 1;
J
Josef Bacik 已提交
4860

4861
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
4862 4863 4864
	if (err)
		goto out_fail;

C
Chris Mason 已提交
4865 4866 4867
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

4868
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
4869 4870 4871
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
4872

4873 4874
	err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
			     dentry->d_name.len, 0, index);
C
Chris Mason 已提交
4875 4876
	if (err)
		goto out_fail;
4877

C
Chris Mason 已提交
4878 4879 4880 4881
	d_instantiate(dentry, inode);
	drop_on_err = 0;

out_fail:
4882
	nr = trans->blocks_used;
4883
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
4884 4885
	if (drop_on_err)
		iput(inode);
4886
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4887 4888 4889
	return err;
}

4890 4891 4892 4893
/* 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.
 */
4894 4895
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
4896 4897
				struct extent_map *em,
				u64 map_start, u64 map_len)
4898 4899 4900
{
	u64 start_diff;

4901 4902 4903 4904
	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;
4905 4906
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
4907
		em->block_start += start_diff;
4908 4909
		em->block_len -= start_diff;
	}
4910
	return add_extent_mapping(em_tree, em);
4911 4912
}

4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
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;
4924
	int compress_type;
4925 4926

	WARN_ON(pg_offset != 0);
4927
	compress_type = btrfs_file_extent_compression(leaf, item);
4928 4929 4930 4931
	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);
4932 4933
	if (!tmp)
		return -ENOMEM;
4934 4935 4936 4937
	ptr = btrfs_file_extent_inline_start(item);

	read_extent_buffer(leaf, tmp, ptr, inline_size);

4938
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
4939 4940
	ret = btrfs_decompress(compress_type, tmp, page,
			       extent_offset, inline_size, max_size);
4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952
	if (ret) {
		char *kaddr = kmap_atomic(page, KM_USER0);
		unsigned long copy_size = min_t(u64,
				  PAGE_CACHE_SIZE - pg_offset,
				  max_size - extent_offset);
		memset(kaddr + pg_offset, 0, copy_size);
		kunmap_atomic(kaddr, KM_USER0);
	}
	kfree(tmp);
	return 0;
}

4953 4954
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
4955 4956
 * 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,
4957 4958 4959 4960
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
4961

4962
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
4963
				    size_t pg_offset, u64 start, u64 len,
4964 4965 4966 4967
				    int create)
{
	int ret;
	int err = 0;
4968
	u64 bytenr;
4969 4970
	u64 extent_start = 0;
	u64 extent_end = 0;
4971
	u64 objectid = btrfs_ino(inode);
4972
	u32 found_type;
4973
	struct btrfs_path *path = NULL;
4974 4975
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
4976 4977
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
4978 4979
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4980
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4981
	struct btrfs_trans_handle *trans = NULL;
4982
	int compress_type;
4983 4984

again:
4985
	read_lock(&em_tree->lock);
4986
	em = lookup_extent_mapping(em_tree, start, len);
4987 4988
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
4989
	read_unlock(&em_tree->lock);
4990

4991
	if (em) {
4992 4993 4994
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
4995 4996 4997
			free_extent_map(em);
		else
			goto out;
4998
	}
4999
	em = alloc_extent_map();
5000
	if (!em) {
5001 5002
		err = -ENOMEM;
		goto out;
5003
	}
5004
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5005
	em->start = EXTENT_MAP_HOLE;
5006
	em->orig_start = EXTENT_MAP_HOLE;
5007
	em->len = (u64)-1;
5008
	em->block_len = (u64)-1;
5009 5010 5011

	if (!path) {
		path = btrfs_alloc_path();
5012 5013 5014 5015 5016 5017 5018 5019 5020
		if (!path) {
			err = -ENOMEM;
			goto out;
		}
		/*
		 * Chances are we'll be called again, so go ahead and do
		 * readahead
		 */
		path->reada = 1;
5021 5022
	}

5023 5024
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

5036 5037
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
5038 5039
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
5040 5041 5042
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
5043 5044 5045 5046
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

5047 5048
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
5049
	compress_type = btrfs_file_extent_compression(leaf, item);
5050 5051
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5052
		extent_end = extent_start +
5053
		       btrfs_file_extent_num_bytes(leaf, item);
5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067
	} 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;
5068
			}
5069 5070 5071
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
5072
		}
5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083
		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;
		em->len = found_key.offset - start;
		goto not_found_em;
	}

5084 5085
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
5086 5087
		em->start = extent_start;
		em->len = extent_end - extent_start;
5088 5089
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
5090 5091
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
5092
			em->block_start = EXTENT_MAP_HOLE;
5093 5094
			goto insert;
		}
5095
		if (compress_type != BTRFS_COMPRESS_NONE) {
5096
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5097
			em->compress_type = compress_type;
5098 5099 5100 5101 5102 5103 5104
			em->block_start = bytenr;
			em->block_len = btrfs_file_extent_disk_num_bytes(leaf,
									 item);
		} else {
			bytenr += btrfs_file_extent_offset(leaf, item);
			em->block_start = bytenr;
			em->block_len = em->len;
5105 5106
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
5107
		}
5108 5109
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
5110
		unsigned long ptr;
5111
		char *map;
5112 5113 5114
		size_t size;
		size_t extent_offset;
		size_t copy_size;
5115

5116
		em->block_start = EXTENT_MAP_INLINE;
5117
		if (!page || create) {
5118
			em->start = extent_start;
5119
			em->len = extent_end - extent_start;
5120 5121
			goto out;
		}
5122

5123 5124
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
5125
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
5126 5127
				size - extent_offset);
		em->start = extent_start + extent_offset;
5128 5129
		em->len = (copy_size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
5130
		em->orig_start = EXTENT_MAP_INLINE;
5131
		if (compress_type) {
5132
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
5133 5134
			em->compress_type = compress_type;
		}
5135
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
5136
		if (create == 0 && !PageUptodate(page)) {
5137 5138
			if (btrfs_file_extent_compression(leaf, item) !=
			    BTRFS_COMPRESS_NONE) {
5139 5140 5141 5142 5143 5144 5145 5146
				ret = uncompress_inline(path, inode, page,
							pg_offset,
							extent_offset, item);
				BUG_ON(ret);
			} else {
				map = kmap(page);
				read_extent_buffer(leaf, map + pg_offset, ptr,
						   copy_size);
5147 5148 5149 5150 5151
				if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
					memset(map + pg_offset + copy_size, 0,
					       PAGE_CACHE_SIZE - pg_offset -
					       copy_size);
				}
5152 5153
				kunmap(page);
			}
5154 5155
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
5156
			BUG();
5157 5158 5159 5160
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
C
Chris Mason 已提交
5161

5162
				btrfs_release_path(path);
5163
				trans = btrfs_join_transaction(root);
C
Chris Mason 已提交
5164

5165 5166
				if (IS_ERR(trans))
					return ERR_CAST(trans);
5167 5168
				goto again;
			}
5169
			map = kmap(page);
5170
			write_extent_buffer(leaf, map + pg_offset, ptr,
5171
					    copy_size);
5172
			kunmap(page);
5173
			btrfs_mark_buffer_dirty(leaf);
5174
		}
5175
		set_extent_uptodate(io_tree, em->start,
5176
				    extent_map_end(em) - 1, NULL, GFP_NOFS);
5177 5178
		goto insert;
	} else {
5179
		printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
5180 5181 5182 5183
		WARN_ON(1);
	}
not_found:
	em->start = start;
5184
	em->len = len;
5185
not_found_em:
5186
	em->block_start = EXTENT_MAP_HOLE;
5187
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
5188
insert:
5189
	btrfs_release_path(path);
5190
	if (em->start > start || extent_map_end(em) <= start) {
5191 5192 5193 5194 5195
		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);
5196 5197 5198
		err = -EIO;
		goto out;
	}
5199 5200

	err = 0;
5201
	write_lock(&em_tree->lock);
5202
	ret = add_extent_mapping(em_tree, em);
5203 5204 5205 5206
	/* 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
	 */
5207
	if (ret == -EEXIST) {
5208
		struct extent_map *existing;
5209 5210 5211

		ret = 0;

5212
		existing = lookup_extent_mapping(em_tree, start, len);
5213 5214 5215 5216 5217
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
5218 5219 5220 5221 5222
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
5223 5224
							   em, start,
							   root->sectorsize);
5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237
				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;
5238
			err = 0;
5239 5240
		}
	}
5241
	write_unlock(&em_tree->lock);
5242
out:
5243 5244 5245

	trace_btrfs_get_extent(root, em);

5246 5247
	if (path)
		btrfs_free_path(path);
5248 5249
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
5250
		if (!err)
5251 5252 5253 5254 5255 5256 5257 5258 5259
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
	return em;
}

5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321
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;

5322
		em = alloc_extent_map();
5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381
		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;
}

5382
static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
5383
						  struct extent_map *em,
5384 5385 5386 5387 5388 5389 5390 5391
						  u64 start, u64 len)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct btrfs_key ins;
	u64 alloc_hint;
	int ret;
5392
	bool insert = false;
5393

5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406
	/*
	 * Ok if the extent map we looked up is a hole and is for the exact
	 * range we want, there is no reason to allocate a new one, however if
	 * it is not right then we need to free this one and drop the cache for
	 * our range.
	 */
	if (em->block_start != EXTENT_MAP_HOLE || em->start != start ||
	    em->len != len) {
		free_extent_map(em);
		em = NULL;
		insert = true;
		btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
	}
5407

5408
	trans = btrfs_join_transaction(root);
5409 5410
	if (IS_ERR(trans))
		return ERR_CAST(trans);
5411

5412 5413 5414
	if (start <= BTRFS_I(inode)->disk_i_size && len < 64 * 1024)
		btrfs_add_inode_defrag(trans, inode);

5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425
	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,
				   alloc_hint, (u64)-1, &ins, 1);
	if (ret) {
		em = ERR_PTR(ret);
		goto out;
	}

	if (!em) {
5426
		em = alloc_extent_map();
5427 5428 5429 5430
		if (!em) {
			em = ERR_PTR(-ENOMEM);
			goto out;
		}
5431 5432 5433 5434 5435 5436 5437 5438 5439
	}

	em->start = start;
	em->orig_start = em->start;
	em->len = ins.offset;

	em->block_start = ins.objectid;
	em->block_len = ins.offset;
	em->bdev = root->fs_info->fs_devices->latest_bdev;
5440 5441 5442 5443 5444 5445

	/*
	 * We need to do this because if we're using the original em we searched
	 * for, we could have EXTENT_FLAG_VACANCY set, and we don't want that.
	 */
	em->flags = 0;
5446 5447
	set_bit(EXTENT_FLAG_PINNED, &em->flags);

5448
	while (insert) {
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467
		write_lock(&em_tree->lock);
		ret = add_extent_mapping(em_tree, em);
		write_unlock(&em_tree->lock);
		if (ret != -EEXIST)
			break;
		btrfs_drop_extent_cache(inode, start, start + em->len - 1, 0);
	}

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

5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491
/*
 * 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;

5492
	ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
				       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);
5509
	if (key.objectid != btrfs_ino(inode) ||
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542
	    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
	 */
5543
	if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567
				  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;
}

5568 5569 5570 5571 5572 5573 5574
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;
	u64 start = iblock << inode->i_blkbits;
	u64 len = bh_result->b_size;
5575
	struct btrfs_trans_handle *trans;
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

	em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
	if (IS_ERR(em))
		return PTR_ERR(em);

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

	/* 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);
		/* DIO will do one hole at a time, so just unlock a sector */
		unlock_extent(&BTRFS_I(inode)->io_tree, start,
			      start + root->sectorsize - 1, GFP_NOFS);
		return 0;
	}

	/*
	 * 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.
	 *
	 */
5620 5621
	if (!create) {
		len = em->len - (start - em->start);
5622
		goto map;
5623
	}
5624 5625 5626 5627 5628 5629

	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;
5630
		u64 block_start;
5631 5632 5633 5634 5635

		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
			type = BTRFS_ORDERED_PREALLOC;
		else
			type = BTRFS_ORDERED_NOCOW;
5636
		len = min(len, em->len - (start - em->start));
5637
		block_start = em->block_start + (start - em->start);
5638 5639 5640 5641 5642 5643

		/*
		 * 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
		 */
5644
		trans = btrfs_join_transaction(root);
5645
		if (IS_ERR(trans))
5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656
			goto must_cow;

		if (can_nocow_odirect(trans, inode, start, len) == 1) {
			ret = btrfs_add_ordered_extent_dio(inode, start,
					   block_start, len, len, type);
			btrfs_end_transaction(trans, root);
			if (ret) {
				free_extent_map(em);
				return ret;
			}
			goto unlock;
5657
		}
5658
		btrfs_end_transaction(trans, root);
5659
	}
5660 5661 5662 5663 5664 5665
must_cow:
	/*
	 * this will cow the extent, reset the len in case we changed
	 * it above
	 */
	len = bh_result->b_size;
5666
	em = btrfs_new_extent_direct(inode, em, start, len);
5667 5668 5669 5670
	if (IS_ERR(em))
		return PTR_ERR(em);
	len = min(len, em->len - (start - em->start));
unlock:
5671 5672 5673
	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, start + len - 1,
			  EXTENT_LOCKED | EXTENT_DELALLOC | EXTENT_DIRTY, 1,
			  0, NULL, GFP_NOFS);
5674 5675 5676
map:
	bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
		inode->i_blkbits;
5677
	bh_result->b_size = len;
5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694
	bh_result->b_bdev = em->bdev;
	set_buffer_mapped(bh_result);
	if (create && !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
		set_buffer_new(bh_result);

	free_extent_map(em);

	return 0;
}

struct btrfs_dio_private {
	struct inode *inode;
	u64 logical_offset;
	u64 disk_bytenr;
	u64 bytes;
	u32 *csums;
	void *private;
5695 5696 5697 5698 5699 5700 5701 5702

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

	/* IO errors */
	int errors;

	struct bio *orig_bio;
5703 5704 5705 5706
};

static void btrfs_endio_direct_read(struct bio *bio, int err)
{
5707
	struct btrfs_dio_private *dip = bio->bi_private;
5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732
	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;
	u32 *private = dip->csums;

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

			local_irq_save(flags);
			kaddr = kmap_atomic(page, KM_IRQ0);
			csum = btrfs_csum_data(root, kaddr + bvec->bv_offset,
					       csum, bvec->bv_len);
			btrfs_csum_final(csum, (char *)&csum);
			kunmap_atomic(kaddr, KM_IRQ0);
			local_irq_restore(flags);

			flush_dcache_page(bvec->bv_page);
			if (csum != *private) {
5733
				printk(KERN_ERR "btrfs csum failed ino %llu off"
5734
				      " %llu csum %u private %u\n",
5735 5736
				      (unsigned long long)btrfs_ino(inode),
				      (unsigned long long)start,
5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752
				      csum, *private);
				err = -EIO;
			}
		}

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

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

	kfree(dip->csums);
	kfree(dip);
5753 5754 5755 5756

	/* If we had a csum failure make sure to clear the uptodate flag */
	if (err)
		clear_bit(BIO_UPTODATE, &bio->bi_flags);
5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767
	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_trans_handle *trans;
	struct btrfs_ordered_extent *ordered = NULL;
	struct extent_state *cached_state = NULL;
5768 5769
	u64 ordered_offset = dip->logical_offset;
	u64 ordered_bytes = dip->bytes;
5770 5771 5772 5773
	int ret;

	if (err)
		goto out_done;
5774 5775 5776 5777
again:
	ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
						   &ordered_offset,
						   ordered_bytes);
5778
	if (!ret)
5779
		goto out_test;
5780 5781 5782

	BUG_ON(!ordered);

5783
	trans = btrfs_join_transaction(root);
5784
	if (IS_ERR(trans)) {
5785 5786 5787 5788 5789 5790 5791 5792
		err = -ENOMEM;
		goto out;
	}
	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
		ret = btrfs_ordered_update_i_size(inode, 0, ordered);
		if (!ret)
5793
			err = btrfs_update_inode_fallback(trans, root, inode);
5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828
		goto out;
	}

	lock_extent_bits(&BTRFS_I(inode)->io_tree, ordered->file_offset,
			 ordered->file_offset + ordered->len - 1, 0,
			 &cached_state, GFP_NOFS);

	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
		ret = btrfs_mark_extent_written(trans, inode,
						ordered->file_offset,
						ordered->file_offset +
						ordered->len);
		if (ret) {
			err = ret;
			goto out_unlock;
		}
	} else {
		ret = insert_reserved_file_extent(trans, inode,
						  ordered->file_offset,
						  ordered->start,
						  ordered->disk_len,
						  ordered->len,
						  ordered->len,
						  0, 0, 0,
						  BTRFS_FILE_EXTENT_REG);
		unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
				   ordered->file_offset, ordered->len);
		if (ret) {
			err = ret;
			WARN_ON(1);
			goto out_unlock;
		}
	}

	add_pending_csums(trans, inode, ordered->file_offset, &ordered->list);
5829
	ret = btrfs_ordered_update_i_size(inode, 0, ordered);
5830
	if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags))
5831
		btrfs_update_inode_fallback(trans, root, inode);
5832
	ret = 0;
5833 5834 5835 5836 5837 5838 5839
out_unlock:
	unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset,
			     ordered->file_offset + ordered->len - 1,
			     &cached_state, GFP_NOFS);
out:
	btrfs_delalloc_release_metadata(inode, ordered->len);
	btrfs_end_transaction(trans, root);
5840
	ordered_offset = ordered->file_offset + ordered->len;
5841 5842
	btrfs_put_ordered_extent(ordered);
	btrfs_put_ordered_extent(ordered);
5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853

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;
		goto again;
	}
5854 5855 5856 5857 5858
out_done:
	bio->bi_private = dip->private;

	kfree(dip->csums);
	kfree(dip);
5859 5860 5861 5862

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

5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876
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);
	BUG_ON(ret);
	return 0;
}

5877 5878 5879 5880 5881
static void btrfs_end_dio_bio(struct bio *bio, int err)
{
	struct btrfs_dio_private *dip = bio->bi_private;

	if (err) {
5882
		printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
5883
		      "sector %#Lx len %u err no %d\n",
5884
		      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
5885
		      (unsigned long long)bio->bi_sector, bio->bi_size, err);
5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917
		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,
5918
					 u32 *csums, int async_submit)
5919 5920 5921 5922 5923 5924 5925 5926 5927 5928
{
	int write = rw & REQ_WRITE;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

	bio_get(bio);
	ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
	if (ret)
		goto err;

5929 5930 5931 5932
	if (skip_sum)
		goto map;

	if (write && async_submit) {
5933 5934 5935 5936 5937 5938
		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;
5939 5940 5941 5942 5943 5944 5945 5946
	} 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;
5947 5948
	} else if (!skip_sum) {
		ret = btrfs_lookup_bio_sums_dio(root, inode, bio,
5949
					  file_offset, csums);
5950 5951 5952
		if (ret)
			goto err;
	}
5953

5954 5955
map:
	ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976
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 btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
	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;
	u32 *csums = dip->csums;
	int ret = 0;
5977
	int async_submit = 0;
5978
	int write = rw & REQ_WRITE;
5979 5980 5981 5982 5983

	map_length = orig_bio->bi_size;
	ret = btrfs_map_block(map_tree, READ, start_sector << 9,
			      &map_length, NULL, 0);
	if (ret) {
5984
		bio_put(orig_bio);
5985 5986 5987
		return -EIO;
	}

5988 5989 5990 5991 5992
	if (map_length >= orig_bio->bi_size) {
		bio = orig_bio;
		goto submit;
	}

5993
	async_submit = 1;
5994 5995 5996 5997 5998 5999 6000
	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);

6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013
	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,
6014
						     csums, async_submit);
6015 6016 6017 6018 6019 6020
			if (ret) {
				bio_put(bio);
				atomic_dec(&dip->pending_bios);
				goto out_err;
			}

6021 6022
			/* Write's use the ordered csums */
			if (!write && !skip_sum)
6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050
				csums = csums + nr_pages;
			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;
			ret = btrfs_map_block(map_tree, READ, start_sector << 9,
					      &map_length, NULL, 0);
			if (ret) {
				bio_put(bio);
				goto out_err;
			}
		} else {
			submit_len += bvec->bv_len;
			nr_pages ++;
			bvec++;
		}
	}

6051
submit:
6052
	ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
6053
				     csums, async_submit);
6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071
	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;
}

6072 6073 6074 6075 6076 6077 6078
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;
6079
	int write = rw & REQ_WRITE;
6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090
	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->csums = NULL;

6091 6092
	/* Write's use the ordered csum stuff, so we don't need dip->csums */
	if (!write && !skip_sum) {
6093 6094
		dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS);
		if (!dip->csums) {
D
Daniel J Blueman 已提交
6095
			kfree(dip);
6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110
			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));

6111
	dip->disk_bytenr = (u64)bio->bi_sector << 9;
6112
	bio->bi_private = dip;
6113 6114 6115
	dip->errors = 0;
	dip->orig_bio = bio;
	atomic_set(&dip->pending_bios, 0);
6116 6117 6118 6119 6120 6121

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

6122 6123
	ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
	if (!ret)
6124
		return;
6125 6126 6127 6128 6129 6130 6131
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;
6132
		ordered = btrfs_lookup_ordered_extent(inode, file_offset);
6133 6134 6135 6136 6137 6138 6139 6140 6141 6142
		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 已提交
6143 6144 6145 6146 6147
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;
6148
	int i;
C
Chris Mason 已提交
6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162
	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;
6163
		if ((addr & blocksize_mask) || (size & blocksize_mask))
C
Chris Mason 已提交
6164
			goto out;
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178

		/* 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 已提交
6179 6180 6181 6182 6183
	}
	retval = 0;
out:
	return retval;
}
6184 6185 6186 6187
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
6188 6189 6190
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
	struct btrfs_ordered_extent *ordered;
6191
	struct extent_state *cached_state = NULL;
6192 6193
	u64 lockstart, lockend;
	ssize_t ret;
6194 6195
	int writing = rw & WRITE;
	int write_bits = 0;
6196
	size_t count = iov_length(iov, nr_segs);
6197

C
Chris Mason 已提交
6198 6199 6200 6201 6202
	if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
			    offset, nr_segs)) {
		return 0;
	}

6203
	lockstart = offset;
6204 6205 6206 6207 6208 6209 6210
	lockend = offset + count - 1;

	if (writing) {
		ret = btrfs_delalloc_reserve_space(inode, count);
		if (ret)
			goto out;
	}
6211

6212
	while (1) {
6213 6214
		lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
				 0, &cached_state, GFP_NOFS);
6215 6216 6217 6218 6219 6220 6221 6222 6223
		/*
		 * 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);
		if (!ordered)
			break;
6224 6225
		unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
				     &cached_state, GFP_NOFS);
6226 6227 6228 6229 6230
		btrfs_start_ordered_extent(inode, ordered, 1);
		btrfs_put_ordered_extent(ordered);
		cond_resched();
	}

6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250
	/*
	 * we don't use btrfs_set_extent_delalloc because we don't want
	 * the dirty or uptodate bits
	 */
	if (writing) {
		write_bits = EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING;
		ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
				     EXTENT_DELALLOC, 0, NULL, &cached_state,
				     GFP_NOFS);
		if (ret) {
			clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
					 lockend, EXTENT_LOCKED | write_bits,
					 1, 0, &cached_state, GFP_NOFS);
			goto out;
		}
	}

	free_extent_state(cached_state);
	cached_state = NULL;

C
Chris Mason 已提交
6251 6252 6253 6254
	ret = __blockdev_direct_IO(rw, iocb, inode,
		   BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
		   iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
		   btrfs_submit_direct, 0);
6255 6256

	if (ret < 0 && ret != -EIOCBQUEUED) {
6257 6258 6259 6260
		clear_extent_bit(&BTRFS_I(inode)->io_tree, offset,
			      offset + iov_length(iov, nr_segs) - 1,
			      EXTENT_LOCKED | write_bits, 1, 0,
			      &cached_state, GFP_NOFS);
6261 6262 6263 6264 6265
	} else if (ret >= 0 && ret < iov_length(iov, nr_segs)) {
		/*
		 * We're falling back to buffered, unlock the section we didn't
		 * do IO on.
		 */
6266 6267 6268 6269
		clear_extent_bit(&BTRFS_I(inode)->io_tree, offset + ret,
			      offset + iov_length(iov, nr_segs) - 1,
			      EXTENT_LOCKED | write_bits, 1, 0,
			      &cached_state, GFP_NOFS);
6270
	}
6271 6272
out:
	free_extent_state(cached_state);
6273
	return ret;
6274 6275
}

Y
Yehuda Sadeh 已提交
6276 6277 6278
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
6279
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
Y
Yehuda Sadeh 已提交
6280 6281
}

6282
int btrfs_readpage(struct file *file, struct page *page)
6283
{
6284 6285
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
6286
	return extent_read_full_page(tree, page, btrfs_get_extent, 0);
6287
}
6288

6289
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
6290
{
6291
	struct extent_io_tree *tree;
6292 6293 6294 6295 6296 6297 6298


	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
6299
	tree = &BTRFS_I(page->mapping->host)->io_tree;
6300
	return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
6301 6302
}

6303 6304
int btrfs_writepages(struct address_space *mapping,
		     struct writeback_control *wbc)
6305
{
6306
	struct extent_io_tree *tree;
6307

6308
	tree = &BTRFS_I(mapping->host)->io_tree;
6309 6310 6311
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

6312 6313 6314 6315
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
6316 6317
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
6318 6319 6320
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
6321
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
6322
{
6323 6324
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
6325
	int ret;
6326

6327 6328
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
6329
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
6330 6331 6332 6333
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
6334
	}
6335
	return ret;
C
Chris Mason 已提交
6336 6337
}

6338 6339
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
6340 6341
	if (PageWriteback(page) || PageDirty(page))
		return 0;
6342
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
6343 6344
}

6345
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
6346
{
6347
	struct extent_io_tree *tree;
6348
	struct btrfs_ordered_extent *ordered;
6349
	struct extent_state *cached_state = NULL;
6350 6351
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
6352

6353 6354 6355 6356 6357 6358 6359 6360

	/*
	 * 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
	 */
6361
	wait_on_page_writeback(page);
6362

6363
	tree = &BTRFS_I(page->mapping->host)->io_tree;
6364 6365 6366 6367
	if (offset) {
		btrfs_releasepage(page, GFP_NOFS);
		return;
	}
6368 6369
	lock_extent_bits(tree, page_start, page_end, 0, &cached_state,
			 GFP_NOFS);
6370 6371 6372
	ordered = btrfs_lookup_ordered_extent(page->mapping->host,
					   page_offset(page));
	if (ordered) {
6373 6374 6375 6376
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
6377 6378
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
6379
				 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING, 1, 0,
6380
				 &cached_state, GFP_NOFS);
6381 6382 6383 6384 6385 6386 6387 6388
		/*
		 * whoever cleared the private bit is responsible
		 * for the finish_ordered_io
		 */
		if (TestClearPagePrivate2(page)) {
			btrfs_finish_ordered_io(page->mapping->host,
						page_start, page_end);
		}
6389
		btrfs_put_ordered_extent(ordered);
6390 6391 6392
		cached_state = NULL;
		lock_extent_bits(tree, page_start, page_end, 0, &cached_state,
				 GFP_NOFS);
6393 6394
	}
	clear_extent_bit(tree, page_start, page_end,
6395
		 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
6396
		 EXTENT_DO_ACCOUNTING, 1, 1, &cached_state, GFP_NOFS);
6397 6398
	__btrfs_releasepage(page, GFP_NOFS);

C
Chris Mason 已提交
6399
	ClearPageChecked(page);
6400 6401 6402 6403 6404
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
6405 6406
}

6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421
/*
 * 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.
 */
6422
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
6423
{
6424
	struct page *page = vmf->page;
6425
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
6426
	struct btrfs_root *root = BTRFS_I(inode)->root;
6427 6428
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
6429
	struct extent_state *cached_state = NULL;
6430 6431
	char *kaddr;
	unsigned long zero_start;
6432
	loff_t size;
6433
	int ret;
6434
	int reserved = 0;
6435
	u64 page_start;
6436
	u64 page_end;
6437

6438
	ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
6439
	if (!ret) {
6440
		ret = btrfs_update_time(vma->vm_file);
6441 6442
		reserved = 1;
	}
6443 6444 6445 6446 6447
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
6448 6449 6450
		if (reserved)
			goto out;
		goto out_noreserve;
6451
	}
6452

6453
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
6454
again:
6455 6456
	lock_page(page);
	size = i_size_read(inode);
6457 6458
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
6459

6460
	if ((page->mapping != inode->i_mapping) ||
6461
	    (page_start >= size)) {
6462 6463 6464
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
6465 6466
	wait_on_page_writeback(page);

6467 6468
	lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state,
			 GFP_NOFS);
6469 6470
	set_page_extent_mapped(page);

6471 6472 6473 6474
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
6475 6476
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
6477 6478
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
6479
		unlock_page(page);
6480
		btrfs_start_ordered_extent(inode, ordered, 1);
6481 6482 6483 6484
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

6485 6486 6487 6488 6489 6490 6491
	/*
	 * 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.
	 */
6492
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
6493
			  EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
6494
			  0, 0, &cached_state, GFP_NOFS);
6495

6496 6497
	ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
					&cached_state);
6498
	if (ret) {
6499 6500
		unlock_extent_cached(io_tree, page_start, page_end,
				     &cached_state, GFP_NOFS);
6501 6502 6503
		ret = VM_FAULT_SIGBUS;
		goto out_unlock;
	}
6504
	ret = 0;
6505 6506

	/* page is wholly or partially inside EOF */
6507
	if (page_start + PAGE_CACHE_SIZE > size)
6508
		zero_start = size & ~PAGE_CACHE_MASK;
6509
	else
6510
		zero_start = PAGE_CACHE_SIZE;
6511

6512 6513 6514 6515 6516 6517
	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);
	}
6518
	ClearPageChecked(page);
6519
	set_page_dirty(page);
6520
	SetPageUptodate(page);
6521

6522 6523 6524
	BTRFS_I(inode)->last_trans = root->fs_info->generation;
	BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;

6525
	unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
6526 6527

out_unlock:
6528 6529
	if (!ret)
		return VM_FAULT_LOCKED;
6530
	unlock_page(page);
6531
out:
6532
	btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
6533
out_noreserve:
6534 6535 6536
	return ret;
}

6537
static int btrfs_truncate(struct inode *inode)
C
Chris Mason 已提交
6538 6539
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
6540
	struct btrfs_block_rsv *rsv;
C
Chris Mason 已提交
6541
	int ret;
6542
	int err = 0;
C
Chris Mason 已提交
6543
	struct btrfs_trans_handle *trans;
6544
	unsigned long nr;
6545
	u64 mask = root->sectorsize - 1;
6546
	u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
C
Chris Mason 已提交
6547

6548 6549
	ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
	if (ret)
6550
		return ret;
6551

C
Chris Mason 已提交
6552
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
6553
	btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
C
Chris Mason 已提交
6554

6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593
	/*
	 * 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.
	 */
	rsv = btrfs_alloc_block_rsv(root);
	if (!rsv)
		return -ENOMEM;
6594
	rsv->size = min_size;
6595

6596
	/*
6597
	 * 1 for the truncate slack space
6598 6599 6600 6601
	 * 1 for the orphan item we're going to add
	 * 1 for the orphan item deletion
	 * 1 for updating the inode.
	 */
6602 6603 6604 6605 6606
	trans = btrfs_start_transaction(root, 4);
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out;
	}
6607

6608 6609 6610
	/* Migrate the slack space for the truncate to our reserve */
	ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
				      min_size);
6611
	BUG_ON(ret);
6612 6613 6614 6615

	ret = btrfs_orphan_add(trans, inode);
	if (ret) {
		btrfs_end_transaction(trans, root);
6616
		goto out;
6617 6618
	}

6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638
	/*
	 * 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.
	 */
	if (inode->i_size == 0 && BTRFS_I(inode)->ordered_data_close)
		btrfs_add_ordered_operation(trans, root, inode);

6639
	while (1) {
6640
		ret = btrfs_block_rsv_refill(root, rsv, min_size);
6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652
		if (ret) {
			/*
			 * This can only happen with the original transaction we
			 * started above, every other time we shouldn't have a
			 * transaction started yet.
			 */
			if (ret == -EAGAIN)
				goto end_trans;
			err = ret;
			break;
		}

6653
		if (!trans) {
6654 6655
			/* Just need the 1 for updating the inode */
			trans = btrfs_start_transaction(root, 1);
6656
			if (IS_ERR(trans)) {
6657 6658 6659
				ret = err = PTR_ERR(trans);
				trans = NULL;
				break;
6660
			}
6661 6662
		}

6663 6664
		trans->block_rsv = rsv;

6665 6666 6667
		ret = btrfs_truncate_inode_items(trans, root, inode,
						 inode->i_size,
						 BTRFS_EXTENT_DATA_KEY);
6668 6669
		if (ret != -EAGAIN) {
			err = ret;
6670
			break;
6671
		}
C
Chris Mason 已提交
6672

6673
		trans->block_rsv = &root->fs_info->trans_block_rsv;
6674
		ret = btrfs_update_inode(trans, root, inode);
6675 6676 6677 6678
		if (ret) {
			err = ret;
			break;
		}
6679
end_trans:
6680 6681
		nr = trans->blocks_used;
		btrfs_end_transaction(trans, root);
6682
		trans = NULL;
6683 6684 6685 6686
		btrfs_btree_balance_dirty(root, nr);
	}

	if (ret == 0 && inode->i_nlink > 0) {
6687
		trans->block_rsv = root->orphan_block_rsv;
6688
		ret = btrfs_orphan_del(trans, inode);
6689 6690
		if (ret)
			err = ret;
6691 6692 6693 6694 6695 6696
	} 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);
6697 6698
	}

6699 6700 6701 6702 6703
	if (trans) {
		trans->block_rsv = &root->fs_info->trans_block_rsv;
		ret = btrfs_update_inode(trans, root, inode);
		if (ret && !err)
			err = ret;
6704

6705
		nr = trans->blocks_used;
6706
		ret = btrfs_end_transaction(trans, root);
6707 6708
		btrfs_btree_balance_dirty(root, nr);
	}
6709 6710 6711 6712

out:
	btrfs_free_block_rsv(root, rsv);

6713 6714
	if (ret && !err)
		err = ret;
6715

6716
	return err;
C
Chris Mason 已提交
6717 6718
}

6719 6720 6721
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
6722
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
6723
			     struct btrfs_root *new_root, u64 new_dirid)
C
Chris Mason 已提交
6724 6725
{
	struct inode *inode;
6726
	int err;
6727
	u64 index = 0;
C
Chris Mason 已提交
6728

6729 6730 6731 6732
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
				new_dirid, new_dirid,
				S_IFDIR | (~current_umask() & S_IRWXUGO),
				&index);
6733
	if (IS_ERR(inode))
6734
		return PTR_ERR(inode);
C
Chris Mason 已提交
6735 6736 6737
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

6738
	set_nlink(inode, 1);
6739
	btrfs_i_size_write(inode, 0);
6740

6741 6742
	err = btrfs_update_inode(trans, new_root, inode);
	BUG_ON(err);
6743

6744
	iput(inode);
6745
	return 0;
C
Chris Mason 已提交
6746 6747 6748 6749 6750
}

struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;
Y
Yan, Zheng 已提交
6751
	struct inode *inode;
C
Chris Mason 已提交
6752 6753 6754 6755

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
Y
Yan, Zheng 已提交
6756 6757 6758 6759 6760

	ei->root = NULL;
	ei->space_info = NULL;
	ei->generation = 0;
	ei->sequence = 0;
6761
	ei->last_trans = 0;
6762
	ei->last_sub_trans = 0;
6763
	ei->logged_trans = 0;
Y
Yan, Zheng 已提交
6764 6765 6766
	ei->delalloc_bytes = 0;
	ei->disk_i_size = 0;
	ei->flags = 0;
6767
	ei->csum_bytes = 0;
Y
Yan, Zheng 已提交
6768 6769 6770
	ei->index_cnt = (u64)-1;
	ei->last_unlink_trans = 0;

6771 6772 6773
	spin_lock_init(&ei->lock);
	ei->outstanding_extents = 0;
	ei->reserved_extents = 0;
Y
Yan, Zheng 已提交
6774 6775

	ei->ordered_data_close = 0;
6776
	ei->orphan_meta_reserved = 0;
Y
Yan, Zheng 已提交
6777
	ei->dummy_inode = 0;
6778
	ei->in_defrag = 0;
6779
	ei->delalloc_meta_reserved = 0;
6780
	ei->force_compress = BTRFS_COMPRESS_NONE;
Y
Yan, Zheng 已提交
6781

6782 6783
	ei->delayed_node = NULL;

Y
Yan, Zheng 已提交
6784
	inode = &ei->vfs_inode;
6785
	extent_map_tree_init(&ei->extent_tree);
6786 6787
	extent_io_tree_init(&ei->io_tree, &inode->i_data);
	extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
Y
Yan, Zheng 已提交
6788
	mutex_init(&ei->log_mutex);
6789
	mutex_init(&ei->delalloc_mutex);
6790
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
6791
	INIT_LIST_HEAD(&ei->i_orphan);
Y
Yan, Zheng 已提交
6792
	INIT_LIST_HEAD(&ei->delalloc_inodes);
6793
	INIT_LIST_HEAD(&ei->ordered_operations);
Y
Yan, Zheng 已提交
6794 6795 6796
	RB_CLEAR_NODE(&ei->rb_node);

	return inode;
C
Chris Mason 已提交
6797 6798
}

N
Nick Piggin 已提交
6799 6800 6801 6802 6803 6804
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 已提交
6805 6806
void btrfs_destroy_inode(struct inode *inode)
{
6807
	struct btrfs_ordered_extent *ordered;
6808 6809
	struct btrfs_root *root = BTRFS_I(inode)->root;

C
Chris Mason 已提交
6810 6811
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);
6812 6813
	WARN_ON(BTRFS_I(inode)->outstanding_extents);
	WARN_ON(BTRFS_I(inode)->reserved_extents);
6814 6815
	WARN_ON(BTRFS_I(inode)->delalloc_bytes);
	WARN_ON(BTRFS_I(inode)->csum_bytes);
C
Chris Mason 已提交
6816

6817 6818 6819 6820 6821 6822 6823 6824
	/*
	 * 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;

6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835
	/*
	 * 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);
	}

6836
	spin_lock(&root->orphan_lock);
6837
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
6838 6839
		printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
		       (unsigned long long)btrfs_ino(inode));
6840
		list_del_init(&BTRFS_I(inode)->i_orphan);
6841
	}
6842
	spin_unlock(&root->orphan_lock);
6843

6844
	while (1) {
6845 6846 6847 6848
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
6849 6850 6851 6852
			printk(KERN_ERR "btrfs found ordered "
			       "extent %llu %llu on inode cleanup\n",
			       (unsigned long long)ordered->file_offset,
			       (unsigned long long)ordered->len);
6853 6854 6855 6856 6857
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
6858
	inode_tree_del(inode);
6859
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
6860
free:
6861
	btrfs_remove_delayed_node(inode);
N
Nick Piggin 已提交
6862
	call_rcu(&inode->i_rcu, btrfs_i_callback);
C
Chris Mason 已提交
6863 6864
}

6865
int btrfs_drop_inode(struct inode *inode)
6866 6867
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
6868

6869
	if (btrfs_root_refs(&root->root_item) == 0 &&
6870
	    !btrfs_is_free_space_inode(root, inode))
6871
		return 1;
6872
	else
6873
		return generic_drop_inode(inode);
6874 6875
}

6876
static void init_once(void *foo)
C
Chris Mason 已提交
6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
	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);
6893 6894
	if (btrfs_free_space_cachep)
		kmem_cache_destroy(btrfs_free_space_cachep);
C
Chris Mason 已提交
6895 6896 6897 6898
}

int btrfs_init_cachep(void)
{
6899 6900 6901
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
			sizeof(struct btrfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
C
Chris Mason 已提交
6902 6903
	if (!btrfs_inode_cachep)
		goto fail;
6904 6905 6906 6907

	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
			sizeof(struct btrfs_trans_handle), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
6908 6909
	if (!btrfs_trans_handle_cachep)
		goto fail;
6910 6911 6912 6913

	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
6914 6915
	if (!btrfs_transaction_cachep)
		goto fail;
6916 6917 6918 6919

	btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
			sizeof(struct btrfs_path), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
6920 6921
	if (!btrfs_path_cachep)
		goto fail;
6922

6923 6924 6925 6926 6927 6928
	btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
			sizeof(struct btrfs_free_space), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
	if (!btrfs_free_space_cachep)
		goto fail;

C
Chris Mason 已提交
6929 6930 6931 6932 6933 6934 6935 6936 6937 6938
	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;
6939 6940
	u32 blocksize = inode->i_sb->s_blocksize;

C
Chris Mason 已提交
6941
	generic_fillattr(inode, stat);
6942
	stat->dev = BTRFS_I(inode)->root->anon_dev;
6943
	stat->blksize = PAGE_CACHE_SIZE;
6944 6945
	stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
		ALIGN(BTRFS_I(inode)->delalloc_bytes, blocksize)) >> 9;
C
Chris Mason 已提交
6946 6947 6948
	return 0;
}

6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968
/*
 * 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;

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

6969 6970
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
6971 6972 6973
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
6974
	struct btrfs_root *dest = BTRFS_I(new_dir)->root;
C
Chris Mason 已提交
6975 6976 6977
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
6978
	u64 index = 0;
6979
	u64 root_objectid;
C
Chris Mason 已提交
6980
	int ret;
6981
	u64 old_ino = btrfs_ino(old_inode);
C
Chris Mason 已提交
6982

6983
	if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
6984 6985
		return -EPERM;

6986
	/* we only allow rename subvolume link between subvolumes */
6987
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
6988 6989
		return -EXDEV;

6990 6991
	if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
	    (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
C
Chris Mason 已提交
6992
		return -ENOTEMPTY;
6993

6994 6995 6996
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
		return -ENOTEMPTY;
6997 6998 6999 7000 7001
	/*
	 * 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
	 */
7002
	if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
7003 7004 7005
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

7006
	/* close the racy window with snapshot create/destroy ioctl */
7007
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
7008
		down_read(&root->fs_info->subvol_sem);
7009 7010 7011 7012 7013 7014 7015 7016 7017
	/*
	 * 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);
7018 7019 7020 7021
	if (IS_ERR(trans)) {
                ret = PTR_ERR(trans);
                goto out_notrans;
        }
7022

7023 7024
	if (dest != root)
		btrfs_record_root_in_trans(trans, dest);
7025

7026 7027 7028
	ret = btrfs_set_inode_index(new_dir, &index);
	if (ret)
		goto out_fail;
7029

7030
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
7031 7032 7033
		/* force full log commit if subvolume involved. */
		root->fs_info->last_trans_log_full_commit = trans->transid;
	} else {
7034 7035 7036
		ret = btrfs_insert_inode_ref(trans, dest,
					     new_dentry->d_name.name,
					     new_dentry->d_name.len,
7037 7038
					     old_ino,
					     btrfs_ino(new_dir), index);
7039 7040
		if (ret)
			goto out_fail;
7041 7042 7043 7044 7045 7046 7047 7048 7049
		/*
		 * 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);
	}
7050 7051 7052 7053
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
7054
	if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
7055 7056
		btrfs_add_ordered_operation(trans, root, old_inode);

C
Chris Mason 已提交
7057 7058 7059
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
7060

7061 7062 7063
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

7064
	if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
7065 7066 7067 7068 7069
		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 {
7070 7071 7072 7073 7074 7075
		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);
7076 7077
	}
	BUG_ON(ret);
C
Chris Mason 已提交
7078 7079 7080

	if (new_inode) {
		new_inode->i_ctime = CURRENT_TIME;
7081
		if (unlikely(btrfs_ino(new_inode) ==
7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095
			     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);
		}
		BUG_ON(ret);
7096
		if (new_inode->i_nlink == 0) {
7097
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
7098
			BUG_ON(ret);
7099
		}
C
Chris Mason 已提交
7100
	}
7101

7102 7103
	fixup_inode_flags(new_dir, old_inode);

7104 7105
	ret = btrfs_add_link(trans, new_dir, old_inode,
			     new_dentry->d_name.name,
7106
			     new_dentry->d_name.len, 0, index);
7107
	BUG_ON(ret);
C
Chris Mason 已提交
7108

7109
	if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
7110
		struct dentry *parent = new_dentry->d_parent;
7111
		btrfs_log_new_name(trans, old_inode, old_dir, parent);
7112 7113
		btrfs_end_log_trans(root);
	}
C
Chris Mason 已提交
7114
out_fail:
7115
	btrfs_end_transaction(trans, root);
7116
out_notrans:
7117
	if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
7118
		up_read(&root->fs_info->subvol_sem);
7119

C
Chris Mason 已提交
7120 7121 7122
	return ret;
}

7123 7124 7125 7126
/*
 * 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 已提交
7127
int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
7128 7129 7130
{
	struct list_head *head = &root->fs_info->delalloc_inodes;
	struct btrfs_inode *binode;
7131
	struct inode *inode;
7132

7133 7134 7135
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

7136
	spin_lock(&root->fs_info->delalloc_lock);
7137
	while (!list_empty(head)) {
7138 7139
		binode = list_entry(head->next, struct btrfs_inode,
				    delalloc_inodes);
7140 7141 7142
		inode = igrab(&binode->vfs_inode);
		if (!inode)
			list_del_init(&binode->delalloc_inodes);
7143
		spin_unlock(&root->fs_info->delalloc_lock);
7144
		if (inode) {
7145
			filemap_flush(inode->i_mapping);
Y
Yan, Zheng 已提交
7146 7147 7148 7149
			if (delay_iput)
				btrfs_add_delayed_iput(inode);
			else
				iput(inode);
7150 7151
		}
		cond_resched();
7152
		spin_lock(&root->fs_info->delalloc_lock);
7153
	}
7154
	spin_unlock(&root->fs_info->delalloc_lock);
7155 7156 7157 7158 7159 7160

	/* 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);
7161
	while (atomic_read(&root->fs_info->nr_async_submits) ||
7162
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
7163
		wait_event(root->fs_info->async_submit_wait,
7164 7165
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
7166 7167
	}
	atomic_dec(&root->fs_info->async_submit_draining);
7168 7169 7170
	return 0;
}

C
Chris Mason 已提交
7171 7172 7173 7174 7175 7176 7177
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;
7178
	struct inode *inode = NULL;
C
Chris Mason 已提交
7179 7180 7181
	int err;
	int drop_inode = 0;
	u64 objectid;
7182
	u64 index = 0 ;
C
Chris Mason 已提交
7183 7184
	int name_len;
	int datasize;
7185
	unsigned long ptr;
C
Chris Mason 已提交
7186
	struct btrfs_file_extent_item *ei;
7187
	struct extent_buffer *leaf;
7188
	unsigned long nr = 0;
C
Chris Mason 已提交
7189 7190 7191 7192

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

7194 7195 7196 7197 7198
	/*
	 * 2 items for inode item and ref
	 * 2 items for dir items
	 * 1 item for xattr if selinux is on
	 */
7199 7200 7201
	trans = btrfs_start_transaction(root, 5);
	if (IS_ERR(trans))
		return PTR_ERR(trans);
7202

7203 7204 7205 7206
	err = btrfs_find_free_ino(root, &objectid);
	if (err)
		goto out_unlock;

7207
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
7208
				dentry->d_name.len, btrfs_ino(dir), objectid,
7209
				S_IFLNK|S_IRWXUGO, &index);
7210 7211
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
C
Chris Mason 已提交
7212
		goto out_unlock;
7213
	}
C
Chris Mason 已提交
7214

7215
	err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
J
Josef Bacik 已提交
7216 7217 7218 7219 7220
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

7221 7222 7223 7224 7225 7226 7227 7228 7229
	/*
	* 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;

7230
	err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
C
Chris Mason 已提交
7231 7232 7233 7234
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
7235
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7236
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
7237 7238 7239 7240 7241
	}
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
7242 7243 7244 7245 7246
	if (!path) {
		err = -ENOMEM;
		drop_inode = 1;
		goto out_unlock;
	}
7247
	key.objectid = btrfs_ino(inode);
C
Chris Mason 已提交
7248 7249 7250 7251 7252
	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);
7253 7254
	if (err) {
		drop_inode = 1;
7255
		btrfs_free_path(path);
7256 7257
		goto out_unlock;
	}
7258 7259 7260 7261 7262
	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 已提交
7263
				   BTRFS_FILE_EXTENT_INLINE);
7264 7265 7266 7267 7268
	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 已提交
7269
	ptr = btrfs_file_extent_inline_start(ei);
7270 7271
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
7272
	btrfs_free_path(path);
7273

C
Chris Mason 已提交
7274 7275
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
7276
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
7277
	inode_set_bytes(inode, name_len);
7278
	btrfs_i_size_write(inode, name_len - 1);
7279 7280 7281
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
7282 7283

out_unlock:
7284 7285
	if (!err)
		d_instantiate(dentry, inode);
7286
	nr = trans->blocks_used;
7287
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
7288 7289 7290 7291
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
7292
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
7293 7294
	return err;
}
7295

7296 7297 7298 7299
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)
7300 7301 7302 7303
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 cur_offset = start;
7304
	u64 i_size;
7305
	int ret = 0;
7306
	bool own_trans = true;
7307

7308 7309
	if (trans)
		own_trans = false;
7310
	while (num_bytes > 0) {
7311 7312 7313 7314 7315 7316
		if (own_trans) {
			trans = btrfs_start_transaction(root, 3);
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				break;
			}
7317 7318
		}

7319 7320
		ret = btrfs_reserve_extent(trans, root, num_bytes, min_size,
					   0, *alloc_hint, (u64)-1, &ins, 1);
7321
		if (ret) {
7322 7323
			if (own_trans)
				btrfs_end_transaction(trans, root);
7324
			break;
7325
		}
7326

7327 7328 7329
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
7330
						  ins.offset, 0, 0, 0,
7331 7332
						  BTRFS_FILE_EXTENT_PREALLOC);
		BUG_ON(ret);
7333 7334
		btrfs_drop_extent_cache(inode, cur_offset,
					cur_offset + ins.offset -1, 0);
7335

7336 7337
		num_bytes -= ins.offset;
		cur_offset += ins.offset;
7338
		*alloc_hint = ins.objectid + ins.offset;
7339

7340
		inode->i_ctime = CURRENT_TIME;
7341
		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
7342
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
7343 7344
		    (actual_len > inode->i_size) &&
		    (cur_offset > inode->i_size)) {
7345
			if (cur_offset > actual_len)
7346
				i_size = actual_len;
7347
			else
7348 7349 7350
				i_size = cur_offset;
			i_size_write(inode, i_size);
			btrfs_ordered_update_i_size(inode, i_size, NULL);
7351 7352
		}

7353 7354 7355
		ret = btrfs_update_inode(trans, root, inode);
		BUG_ON(ret);

7356 7357
		if (own_trans)
			btrfs_end_transaction(trans, root);
7358
	}
7359 7360 7361
	return ret;
}

7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379
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);
}

7380 7381 7382 7383 7384
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

7385
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
7386
{
7387
	struct btrfs_root *root = BTRFS_I(inode)->root;
7388
	umode_t mode = inode->i_mode;
7389

7390 7391 7392 7393 7394 7395 7396
	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;
	}
7397
	return generic_permission(inode, mask);
Y
Yan 已提交
7398
}
C
Chris Mason 已提交
7399

7400
static const struct inode_operations btrfs_dir_inode_operations = {
7401
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
7402 7403 7404 7405 7406 7407 7408 7409 7410
	.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 已提交
7411
	.mknod		= btrfs_mknod,
7412 7413
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7414
	.listxattr	= btrfs_listxattr,
7415
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
7416
	.permission	= btrfs_permission,
7417
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7418
};
7419
static const struct inode_operations btrfs_dir_ro_inode_operations = {
C
Chris Mason 已提交
7420
	.lookup		= btrfs_lookup,
Y
Yan 已提交
7421
	.permission	= btrfs_permission,
7422
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7423
};
7424

7425
static const struct file_operations btrfs_dir_file_operations = {
C
Chris Mason 已提交
7426 7427
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
7428
	.readdir	= btrfs_real_readdir,
7429
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
7430
#ifdef CONFIG_COMPAT
7431
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
7432
#endif
S
Sage Weil 已提交
7433
	.release        = btrfs_release_file,
7434
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
7435 7436
};

7437
static struct extent_io_ops btrfs_extent_io_ops = {
7438
	.fill_delalloc = run_delalloc_range,
7439
	.submit_bio_hook = btrfs_submit_bio_hook,
7440
	.merge_bio_hook = btrfs_merge_bio_hook,
7441
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
7442
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
7443
	.writepage_start_hook = btrfs_writepage_start_hook,
7444 7445
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
7446 7447
	.merge_extent_hook = btrfs_merge_extent_hook,
	.split_extent_hook = btrfs_split_extent_hook,
7448 7449
};

7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461
/*
 * 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.
 */
7462
static const struct address_space_operations btrfs_aops = {
C
Chris Mason 已提交
7463 7464
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
7465
	.writepages	= btrfs_writepages,
7466
	.readpages	= btrfs_readpages,
7467
	.direct_IO	= btrfs_direct_IO,
7468 7469
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
7470
	.set_page_dirty	= btrfs_set_page_dirty,
7471
	.error_remove_page = generic_error_remove_page,
C
Chris Mason 已提交
7472 7473
};

7474
static const struct address_space_operations btrfs_symlink_aops = {
C
Chris Mason 已提交
7475 7476
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
7477 7478
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
7479 7480
};

7481
static const struct inode_operations btrfs_file_inode_operations = {
C
Chris Mason 已提交
7482 7483
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
7484 7485
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7486
	.listxattr      = btrfs_listxattr,
7487
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
7488
	.permission	= btrfs_permission,
Y
Yehuda Sadeh 已提交
7489
	.fiemap		= btrfs_fiemap,
7490
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7491
};
7492
static const struct inode_operations btrfs_special_inode_operations = {
J
Josef Bacik 已提交
7493 7494
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
7495
	.permission	= btrfs_permission,
7496 7497
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
7498
	.listxattr	= btrfs_listxattr,
7499
	.removexattr	= btrfs_removexattr,
7500
	.get_acl	= btrfs_get_acl,
J
Josef Bacik 已提交
7501
};
7502
static const struct inode_operations btrfs_symlink_inode_operations = {
C
Chris Mason 已提交
7503 7504 7505
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
7506
	.getattr	= btrfs_getattr,
7507
	.setattr	= btrfs_setattr,
Y
Yan 已提交
7508
	.permission	= btrfs_permission,
J
Jim Owens 已提交
7509 7510 7511 7512
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
7513
	.get_acl	= btrfs_get_acl,
C
Chris Mason 已提交
7514
};
7515

7516
const struct dentry_operations btrfs_dentry_operations = {
7517
	.d_delete	= btrfs_dentry_delete,
7518
	.d_release	= btrfs_dentry_release,
7519
};
新手
引导
客服 返回
顶部