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

19
#include <linux/kernel.h>
20
#include <linux/bio.h>
C
Chris Mason 已提交
21
#include <linux/buffer_head.h>
S
Sage Weil 已提交
22
#include <linux/file.h>
C
Chris Mason 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35
#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/smp_lock.h>
#include <linux/backing-dev.h>
#include <linux/mpage.h>
#include <linux/swap.h>
#include <linux/writeback.h>
#include <linux/statfs.h>
#include <linux/compat.h>
C
Chris Mason 已提交
36
#include <linux/bit_spinlock.h>
J
Josef Bacik 已提交
37
#include <linux/xattr.h>
J
Josef Bacik 已提交
38
#include <linux/posix_acl.h>
Y
Yan Zheng 已提交
39
#include <linux/falloc.h>
C
Chris Mason 已提交
40
#include "compat.h"
C
Chris Mason 已提交
41 42 43 44 45 46
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"
47
#include "volumes.h"
48
#include "ordered-data.h"
49
#include "xattr.h"
50
#include "tree-log.h"
Y
Yan Zheng 已提交
51
#include "ref-cache.h"
C
Chris Mason 已提交
52
#include "compression.h"
53
#include "locking.h"
C
Chris Mason 已提交
54 55 56 57 58 59 60 61 62

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

static struct inode_operations btrfs_dir_inode_operations;
static struct inode_operations btrfs_symlink_inode_operations;
static struct inode_operations btrfs_dir_ro_inode_operations;
J
Josef Bacik 已提交
63
static struct inode_operations btrfs_special_inode_operations;
C
Chris Mason 已提交
64 65 66 67
static struct inode_operations btrfs_file_inode_operations;
static struct address_space_operations btrfs_aops;
static struct address_space_operations btrfs_symlink_aops;
static struct file_operations btrfs_dir_file_operations;
68
static struct extent_io_ops btrfs_extent_io_ops;
C
Chris Mason 已提交
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

static struct kmem_cache *btrfs_inode_cachep;
struct kmem_cache *btrfs_trans_handle_cachep;
struct kmem_cache *btrfs_transaction_cachep;
struct kmem_cache *btrfs_bit_radix_cachep;
struct kmem_cache *btrfs_path_cachep;

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

87
static void btrfs_truncate(struct inode *inode);
C
Chris Mason 已提交
88
static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
89 90 91 92
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);
93

J
Jim Owens 已提交
94 95 96 97 98 99 100 101 102 103
static int btrfs_init_inode_security(struct inode *inode,  struct inode *dir)
{
	int err;

	err = btrfs_init_acl(inode, dir);
	if (!err)
		err = btrfs_xattr_security_init(inode, dir);
	return err;
}

C
Chris Mason 已提交
104 105 106 107 108
/*
 * this does all the hard work for inserting an inline extent into
 * the btree.  The caller should have done a btrfs_drop_extents so that
 * no overlapping inline items exist in the btree
 */
C
Chris Mason 已提交
109
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
				struct btrfs_root *root, struct inode *inode,
				u64 start, size_t size, size_t compressed_size,
				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;
	int use_compress = 0;

	if (compressed_size && compressed_pages) {
		use_compress = 1;
		cur_size = compressed_size;
	}

C
Chris Mason 已提交
133 134
	path = btrfs_alloc_path();
	if (!path)
C
Chris Mason 已提交
135 136
		return -ENOMEM;

137
	path->leave_spinning = 1;
C
Chris Mason 已提交
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	btrfs_set_trans_block_group(trans, inode);

	key.objectid = inode->i_ino;
	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);

	if (use_compress) {
		struct page *cpage;
		int i = 0;
C
Chris Mason 已提交
166
		while (compressed_size > 0) {
C
Chris Mason 已提交
167
			cpage = compressed_pages[i];
168
			cur_size = min_t(unsigned long, compressed_size,
C
Chris Mason 已提交
169 170
				       PAGE_CACHE_SIZE);

171
			kaddr = kmap_atomic(cpage, KM_USER0);
C
Chris Mason 已提交
172
			write_extent_buffer(leaf, kaddr, ptr, cur_size);
173
			kunmap_atomic(kaddr, KM_USER0);
C
Chris Mason 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207

			i++;
			ptr += cur_size;
			compressed_size -= cur_size;
		}
		btrfs_set_file_extent_compression(leaf, ei,
						  BTRFS_COMPRESS_ZLIB);
	} 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);

	BTRFS_I(inode)->disk_i_size = inode->i_size;
	btrfs_update_inode(trans, root, inode);
	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.
 */
208
static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
				 struct btrfs_root *root,
				 struct inode *inode, u64 start, u64 end,
				 size_t compressed_size,
				 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 ||
C
Chris Mason 已提交
227
	    actual_end >= PAGE_CACHE_SIZE ||
C
Chris Mason 已提交
228 229 230 231 232 233 234 235 236
	    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;
	}

	ret = btrfs_drop_extents(trans, root, inode, start,
C
Chris Mason 已提交
237
				 aligned_end, start, &hint_byte);
C
Chris Mason 已提交
238 239 240 241 242 243 244 245 246 247 248 249
	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,
				   compressed_pages);
	BUG_ON(ret);
	btrfs_drop_extent_cache(inode, start, aligned_end, 0);
	return 0;
}

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
struct async_extent {
	u64 start;
	u64 ram_size;
	u64 compressed_size;
	struct page **pages;
	unsigned long nr_pages;
	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,
				     unsigned long nr_pages)
{
	struct async_extent *async_extent;

	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
	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;
	list_add_tail(&async_extent->list, &cow->extents);
	return 0;
}

C
Chris Mason 已提交
287
/*
288 289 290
 * we create compressed extents in two phases.  The first
 * phase compresses a range of pages that have already been
 * locked (both pages and state bits are locked).
C
Chris Mason 已提交
291
 *
292 293 294 295 296
 * This is done inside an ordered work queue, and the compression
 * is spread across many cpus.  The actual IO submission is step
 * two, and the ordered work queue takes care of making sure that
 * happens in the same order things were put onto the queue by
 * writepages and friends.
C
Chris Mason 已提交
297
 *
298 299 300 301
 * 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.
C
Chris Mason 已提交
302
 */
303 304 305 306 307
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)
308 309 310
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
311
	u64 num_bytes;
C
Chris Mason 已提交
312 313
	u64 orig_start;
	u64 disk_num_bytes;
314
	u64 blocksize = root->sectorsize;
C
Chris Mason 已提交
315
	u64 actual_end;
316
	u64 isize = i_size_read(inode);
317
	int ret = 0;
C
Chris Mason 已提交
318 319 320 321 322 323
	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;
324
	unsigned long max_uncompressed = 128 * 1024;
C
Chris Mason 已提交
325 326
	int i;
	int will_compress;
327

C
Chris Mason 已提交
328 329
	orig_start = start;

330
	actual_end = min_t(u64, isize, end + 1);
C
Chris Mason 已提交
331 332 333 334
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);
335

336 337 338 339 340 341 342 343 344 345 346 347 348
	/*
	 * we don't want to send crud past the end of i_size through
	 * compression, that's just a waste of CPU time.  So, if the
	 * end of the file is before the start of our current
	 * requested range of bytes, we bail out to the uncompressed
	 * cleanup code that can deal with all of this.
	 *
	 * It isn't really the fastest way to fix things, but this is a
	 * very uncommon corner.
	 */
	if (actual_end <= start)
		goto cleanup_and_bail_uncompressed;

C
Chris Mason 已提交
349 350 351 352
	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
353 354 355 356 357 358 359
	 * of a compressed extent to 128k.  This is a crucial number
	 * because it also controls how easily we can spread reads across
	 * cpus for decompression.
	 *
	 * We also want to make sure the amount of IO required to do
	 * a random read is reasonably small, so we limit the size of
	 * a compressed extent to 128k.
C
Chris Mason 已提交
360 361
	 */
	total_compressed = min(total_compressed, max_uncompressed);
362
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
363
	num_bytes = max(blocksize,  num_bytes);
C
Chris Mason 已提交
364 365 366
	disk_num_bytes = num_bytes;
	total_in = 0;
	ret = 0;
367

368 369 370 371
	/*
	 * we do compression for mount -o compress and when the
	 * inode has not been flagged as nocompress.  This flag can
	 * change at any time if we discover bad compression ratios.
C
Chris Mason 已提交
372 373 374 375
	 */
	if (!btrfs_test_flag(inode, NOCOMPRESS) &&
	    btrfs_test_opt(root, COMPRESS)) {
		WARN_ON(pages);
376
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
C
Chris Mason 已提交
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403

		ret = btrfs_zlib_compress_pages(inode->i_mapping, start,
						total_compressed, pages,
						nr_pages, &nr_pages_ret,
						&total_in,
						&total_compressed,
						max_compressed);

		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;
		}
	}
	if (start == 0) {
404 405 406 407
		trans = btrfs_join_transaction(root, 1);
		BUG_ON(!trans);
		btrfs_set_trans_block_group(trans, inode);

C
Chris Mason 已提交
408
		/* lets try to make an inline extent */
409
		if (ret || total_in < (actual_end - start)) {
C
Chris Mason 已提交
410
			/* we didn't compress the entire range, try
411
			 * to make an uncompressed inline extent.
C
Chris Mason 已提交
412 413 414 415
			 */
			ret = cow_file_range_inline(trans, root, inode,
						    start, end, 0, NULL);
		} else {
416
			/* try making a compressed inline extent */
C
Chris Mason 已提交
417 418 419 420
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
						    total_compressed, pages);
		}
421
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
422
		if (ret == 0) {
423 424 425 426 427
			/*
			 * inline extent creation worked, we don't need
			 * to create any more async work items.  Unlock
			 * and free up our temp pages.
			 */
C
Chris Mason 已提交
428 429
			extent_clear_unlock_delalloc(inode,
						     &BTRFS_I(inode)->io_tree,
430 431
						     start, end, NULL, 1, 0,
						     0, 1, 1, 1);
C
Chris Mason 已提交
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
			ret = 0;
			goto free_pages_out;
		}
	}

	if (will_compress) {
		/*
		 * we aren't doing an inline extent round the compressed size
		 * up to a block size boundary so the allocator does sane
		 * things
		 */
		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 {
			disk_num_bytes = total_compressed;
			num_bytes = total_in;
		}
	}
	if (!will_compress && pages) {
		/*
		 * the compression code ran but failed to make things smaller,
		 * free any pages it allocated and our page pointer array
		 */
		for (i = 0; i < nr_pages_ret; i++) {
C
Chris Mason 已提交
465
			WARN_ON(pages[i]->mapping);
C
Chris Mason 已提交
466 467 468 469 470 471 472 473 474 475
			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 */
		btrfs_set_flag(inode, NOCOMPRESS);
	}
476 477
	if (will_compress) {
		*num_added += 1;
C
Chris Mason 已提交
478

479 480 481 482 483 484
		/* 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,
				 total_compressed, pages, nr_pages_ret);
485

486
		if (start + num_bytes < end && start + num_bytes < actual_end) {
487 488 489 490 491 492
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
493
cleanup_and_bail_uncompressed:
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
		/*
		 * 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 */
		}
		add_async_extent(async_cow, start, end - start + 1, 0, NULL, 0);
		*num_added += 1;
	}
509

510 511 512 513 514 515 516 517
out:
	return 0;

free_pages_out:
	for (i = 0; i < nr_pages_ret; i++) {
		WARN_ON(pages[i]->mapping);
		page_cache_release(pages[i]);
	}
C
Chris Mason 已提交
518
	kfree(pages);
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546

	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;
	int ret;

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

	trans = btrfs_join_transaction(root, 1);

C
Chris Mason 已提交
547
	while (!list_empty(&async_cow->extents)) {
548 549 550
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
C
Chris Mason 已提交
551

552 553 554 555 556 557 558 559
		io_tree = &BTRFS_I(inode)->io_tree;

		/* 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,
C
Chris Mason 已提交
560 561
				    async_extent->start +
				    async_extent->ram_size - 1, GFP_NOFS);
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578

			/* allocate blocks */
			cow_file_range(inode, async_cow->locked_page,
				       async_extent->start,
				       async_extent->start +
				       async_extent->ram_size - 1,
				       &page_started, &nr_written, 0);

			/*
			 * 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.
			 */
			if (!page_started)
				extent_write_locked_range(io_tree,
						  inode, async_extent->start,
C
Chris Mason 已提交
579
						  async_extent->start +
580 581 582 583 584 585 586 587 588 589 590
						  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);
C
Chris Mason 已提交
591
		/*
592 593
		 * here we're doing allocation and writeback of the
		 * compressed pages
C
Chris Mason 已提交
594
		 */
595 596 597 598 599 600 601 602 603 604 605 606 607
		btrfs_drop_extent_cache(inode, async_extent->start,
					async_extent->start +
					async_extent->ram_size - 1, 0);

		ret = btrfs_reserve_extent(trans, root,
					   async_extent->compressed_size,
					   async_extent->compressed_size,
					   0, alloc_hint,
					   (u64)-1, &ins, 1);
		BUG_ON(ret);
		em = alloc_extent_map(GFP_NOFS);
		em->start = async_extent->start;
		em->len = async_extent->ram_size;
608
		em->orig_start = em->start;
C
Chris Mason 已提交
609

610 611 612 613 614 615
		em->block_start = ins.objectid;
		em->block_len = ins.offset;
		em->bdev = root->fs_info->fs_devices->latest_bdev;
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);

C
Chris Mason 已提交
616
		while (1) {
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
			spin_lock(&em_tree->lock);
			ret = add_extent_mapping(em_tree, em);
			spin_unlock(&em_tree->lock);
			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);
		}

		ret = btrfs_add_ordered_extent(inode, async_extent->start,
					       ins.objectid,
					       async_extent->ram_size,
					       ins.offset,
					       BTRFS_ORDERED_COMPRESSED);
		BUG_ON(ret);

		btrfs_end_transaction(trans, root);

		/*
		 * clear dirty, set writeback and unlock the pages.
		 */
		extent_clear_unlock_delalloc(inode,
					     &BTRFS_I(inode)->io_tree,
					     async_extent->start,
					     async_extent->start +
					     async_extent->ram_size - 1,
					     NULL, 1, 1, 0, 1, 1, 0);

		ret = btrfs_submit_compressed_write(inode,
C
Chris Mason 已提交
649 650 651 652 653
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693

		BUG_ON(ret);
		trans = btrfs_join_transaction(root, 1);
		alloc_hint = ins.objectid + ins.offset;
		kfree(async_extent);
		cond_resched();
	}

	btrfs_end_transaction(trans, root);
	return 0;
}

/*
 * 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;
	u64 actual_end;
694
	u64 isize = i_size_read(inode);
695 696 697 698 699 700 701 702 703
	struct btrfs_key ins;
	struct extent_map *em;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	int ret = 0;

	trans = btrfs_join_transaction(root, 1);
	BUG_ON(!trans);
	btrfs_set_trans_block_group(trans, inode);

704
	actual_end = min_t(u64, isize, end + 1);
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732

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

	if (start == 0) {
		/* lets try to make an inline extent */
		ret = cow_file_range_inline(trans, root, inode,
					    start, end, 0, NULL);
		if (ret == 0) {
			extent_clear_unlock_delalloc(inode,
						     &BTRFS_I(inode)->io_tree,
						     start, end, NULL, 1, 1,
						     1, 1, 1, 1);
			*nr_written = *nr_written +
			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
			*page_started = 1;
			ret = 0;
			goto out;
		}
	}

	BUG_ON(disk_num_bytes >
	       btrfs_super_total_bytes(&root->fs_info->super_copy));

	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

C
Chris Mason 已提交
733
	while (disk_num_bytes > 0) {
C
Chris Mason 已提交
734
		cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
735
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
736
					   root->sectorsize, 0, alloc_hint,
737
					   (u64)-1, &ins, 1);
C
Chris Mason 已提交
738 739
		BUG_ON(ret);

740 741
		em = alloc_extent_map(GFP_NOFS);
		em->start = start;
742
		em->orig_start = em->start;
C
Chris Mason 已提交
743

744 745
		ram_size = ins.offset;
		em->len = ins.offset;
C
Chris Mason 已提交
746

747
		em->block_start = ins.objectid;
C
Chris Mason 已提交
748
		em->block_len = ins.offset;
749
		em->bdev = root->fs_info->fs_devices->latest_bdev;
750
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
C
Chris Mason 已提交
751

C
Chris Mason 已提交
752
		while (1) {
753 754 755 756 757 758 759 760
			spin_lock(&em_tree->lock);
			ret = add_extent_mapping(em_tree, em);
			spin_unlock(&em_tree->lock);
			if (ret != -EEXIST) {
				free_extent_map(em);
				break;
			}
			btrfs_drop_extent_cache(inode, start,
C
Chris Mason 已提交
761
						start + ram_size - 1, 0);
762 763
		}

764
		cur_alloc_size = ins.offset;
765
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
766
					       ram_size, cur_alloc_size, 0);
767
		BUG_ON(ret);
C
Chris Mason 已提交
768

769 770 771 772 773 774 775
		if (root->root_key.objectid ==
		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
			ret = btrfs_reloc_clone_csums(inode, start,
						      cur_alloc_size);
			BUG_ON(ret);
		}

C
Chris Mason 已提交
776
		if (disk_num_bytes < cur_alloc_size)
777
			break;
C
Chris Mason 已提交
778

C
Chris Mason 已提交
779 780 781 782 783 784
		/* 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
		 */
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					     start, start + ram_size - 1,
785 786
					     locked_page, unlock, 1,
					     1, 0, 0, 0);
C
Chris Mason 已提交
787
		disk_num_bytes -= cur_alloc_size;
788 789 790
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
791 792
	}
out:
793
	ret = 0;
794
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
795

796
	return ret;
797
}
C
Chris Mason 已提交
798

799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
/*
 * 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);

C
Chris Mason 已提交
837
	if (async_cow->inode)
838 839
		submit_compressed_extents(async_cow->inode, async_cow);
}
C
Chris Mason 已提交
840

841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
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;

	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED |
			 EXTENT_DELALLOC, 1, 0, GFP_NOFS);
C
Chris Mason 已提交
860
	while (start < end) {
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
		async_cow->inode = inode;
		async_cow->root = root;
		async_cow->locked_page = locked_page;
		async_cow->start = start;

		if (btrfs_test_flag(inode, NOCOMPRESS))
			cur_end = end;
		else
			cur_end = min(end, start + 512 * 1024 - 1);

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

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

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

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

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

C
Chris Mason 已提交
893
		while (atomic_read(&root->fs_info->async_submit_draining) &&
894 895 896 897 898 899 900 901 902 903 904
		      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;
905 906
}

C
Chris Mason 已提交
907
static noinline int csum_exist_in_range(struct btrfs_root *root,
908 909 910 911 912 913
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

Y
Yan Zheng 已提交
914 915
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
				       bytenr + num_bytes - 1, &list);
916 917 918 919 920 921 922 923 924 925 926
	if (ret == 0 && list_empty(&list))
		return 0;

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

C
Chris Mason 已提交
927 928 929 930 931 932 933
/*
 * 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
 */
934 935
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
936 937
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
938 939
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
940
	struct btrfs_trans_handle *trans;
941 942
	struct extent_buffer *leaf;
	struct btrfs_path *path;
Y
Yan Zheng 已提交
943
	struct btrfs_file_extent_item *fi;
944
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
945 946 947 948 949 950 951
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
	u64 disk_bytenr;
	u64 num_bytes;
	int extent_type;
	int ret;
Y
Yan Zheng 已提交
952
	int type;
Y
Yan Zheng 已提交
953 954
	int nocow;
	int check_prev = 1;
955 956 957

	path = btrfs_alloc_path();
	BUG_ON(!path);
958 959
	trans = btrfs_join_transaction(root, 1);
	BUG_ON(!trans);
960

Y
Yan Zheng 已提交
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
	cow_start = (u64)-1;
	cur_offset = start;
	while (1) {
		ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
					       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);
			if (found_key.objectid == inode->i_ino &&
			    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];
		}
986

Y
Yan Zheng 已提交
987 988
		nocow = 0;
		disk_bytenr = 0;
989
		num_bytes = 0;
Y
Yan Zheng 已提交
990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

		if (found_key.objectid > inode->i_ino ||
		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
		    found_key.offset > end)
			break;

		if (found_key.offset > cur_offset) {
			extent_end = found_key.offset;
			goto out_check;
		}

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

Y
Yan Zheng 已提交
1006 1007
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
1008 1009 1010 1011 1012 1013 1014
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1015 1016
			if (disk_bytenr == 0)
				goto out_check;
Y
Yan Zheng 已提交
1017 1018 1019 1020
			if (btrfs_file_extent_compression(leaf, fi) ||
			    btrfs_file_extent_encryption(leaf, fi) ||
			    btrfs_file_extent_other_encoding(leaf, fi))
				goto out_check;
Y
Yan Zheng 已提交
1021 1022
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1023
			if (btrfs_extent_readonly(root, disk_bytenr))
Y
Yan Zheng 已提交
1024
				goto out_check;
1025 1026 1027
			if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
						  disk_bytenr))
				goto out_check;
Y
Yan Zheng 已提交
1028
			disk_bytenr += btrfs_file_extent_offset(leaf, fi);
1029 1030 1031 1032 1033 1034 1035 1036 1037
			disk_bytenr += cur_offset - found_key.offset;
			num_bytes = min(end + 1, extent_end) - cur_offset;
			/*
			 * force cow if csum exists in the range.
			 * this ensure that csum for a given extent are
			 * either valid or do not exist.
			 */
			if (csum_exist_in_range(root, disk_bytenr, num_bytes))
				goto out_check;
Y
Yan Zheng 已提交
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
			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;
1059 1060 1061
		}

		btrfs_release_path(root, path);
Y
Yan Zheng 已提交
1062 1063
		if (cow_start != (u64)-1) {
			ret = cow_file_range(inode, locked_page, cow_start,
1064 1065
					found_key.offset - 1, page_started,
					nr_written, 1);
Y
Yan Zheng 已提交
1066 1067
			BUG_ON(ret);
			cow_start = (u64)-1;
1068
		}
Y
Yan Zheng 已提交
1069

Y
Yan Zheng 已提交
1070 1071 1072 1073 1074 1075
		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
			struct extent_map *em;
			struct extent_map_tree *em_tree;
			em_tree = &BTRFS_I(inode)->extent_tree;
			em = alloc_extent_map(GFP_NOFS);
			em->start = cur_offset;
1076
			em->orig_start = em->start;
Y
Yan Zheng 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
			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) {
				spin_lock(&em_tree->lock);
				ret = add_extent_mapping(em_tree, em);
				spin_unlock(&em_tree->lock);
				if (ret != -EEXIST) {
					free_extent_map(em);
					break;
				}
				btrfs_drop_extent_cache(inode, em->start,
						em->start + em->len - 1, 0);
			}
			type = BTRFS_ORDERED_PREALLOC;
		} else {
			type = BTRFS_ORDERED_NOCOW;
		}
Y
Yan Zheng 已提交
1097 1098

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
Y
Yan Zheng 已提交
1099 1100
					       num_bytes, num_bytes, type);
		BUG_ON(ret);
1101

Y
Yan Zheng 已提交
1102 1103
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					cur_offset, cur_offset + num_bytes - 1,
1104
					locked_page, 1, 1, 1, 0, 0, 0);
Y
Yan Zheng 已提交
1105 1106 1107
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1108
	}
Y
Yan Zheng 已提交
1109 1110 1111 1112 1113 1114
	btrfs_release_path(root, path);

	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,
1115
				     page_started, nr_written, 1);
Y
Yan Zheng 已提交
1116 1117 1118 1119 1120
		BUG_ON(ret);
	}

	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
1121
	btrfs_free_path(path);
Y
Yan Zheng 已提交
1122
	return 0;
1123 1124
}

C
Chris Mason 已提交
1125 1126 1127
/*
 * extent_io.c call back to do delayed allocation processing
 */
C
Chris Mason 已提交
1128
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1129 1130
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1131 1132
{
	int ret;
1133
	struct btrfs_root *root = BTRFS_I(inode)->root;
1134

1135
	if (btrfs_test_flag(inode, NODATACOW))
C
Chris Mason 已提交
1136
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1137
					 page_started, 1, nr_written);
Y
Yan Zheng 已提交
1138 1139
	else if (btrfs_test_flag(inode, PREALLOC))
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1140
					 page_started, 0, nr_written);
1141 1142 1143
	else if (!btrfs_test_opt(root, COMPRESS))
		ret = cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
1144
	else
1145
		ret = cow_file_range_async(inode, locked_page, start, end,
C
Chris Mason 已提交
1146
					   page_started, nr_written);
1147 1148 1149
	return ret;
}

C
Chris Mason 已提交
1150 1151 1152 1153 1154
/*
 * 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.
 */
1155
static int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
C
Chris Mason 已提交
1156
		       unsigned long old, unsigned long bits)
1157
{
1158 1159 1160 1161 1162
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
	 * but in this case, we are only testeing for the DELALLOC
	 * bit, which is only set or cleared with irqs on
	 */
C
Chris Mason 已提交
1163
	if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
1164
		struct btrfs_root *root = BTRFS_I(inode)->root;
J
Josef Bacik 已提交
1165
		btrfs_delalloc_reserve_space(root, inode, end - start + 1);
1166
		spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
1167
		BTRFS_I(inode)->delalloc_bytes += end - start + 1;
1168
		root->fs_info->delalloc_bytes += end - start + 1;
1169 1170 1171 1172
		if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
			list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
				      &root->fs_info->delalloc_inodes);
		}
1173
		spin_unlock(&root->fs_info->delalloc_lock);
1174 1175 1176 1177
	}
	return 0;
}

C
Chris Mason 已提交
1178 1179 1180
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1181
static int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
C
Chris Mason 已提交
1182
			 unsigned long old, unsigned long bits)
1183
{
1184 1185 1186 1187 1188
	/*
	 * set_bit and clear bit hooks normally require _irqsave/restore
	 * but in this case, we are only testeing for the DELALLOC
	 * bit, which is only set or cleared with irqs on
	 */
C
Chris Mason 已提交
1189
	if ((old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
1190
		struct btrfs_root *root = BTRFS_I(inode)->root;
1191

1192
		spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
1193
		if (end - start + 1 > root->fs_info->delalloc_bytes) {
C
Chris Mason 已提交
1194 1195 1196 1197 1198
			printk(KERN_INFO "btrfs warning: delalloc account "
			       "%llu %llu\n",
			       (unsigned long long)end - start + 1,
			       (unsigned long long)
			       root->fs_info->delalloc_bytes);
J
Josef Bacik 已提交
1199
			btrfs_delalloc_free_space(root, inode, (u64)-1);
C
Chris Mason 已提交
1200
			root->fs_info->delalloc_bytes = 0;
C
Chris Mason 已提交
1201
			BTRFS_I(inode)->delalloc_bytes = 0;
C
Chris Mason 已提交
1202
		} else {
J
Josef Bacik 已提交
1203 1204
			btrfs_delalloc_free_space(root, inode,
						  end - start + 1);
C
Chris Mason 已提交
1205
			root->fs_info->delalloc_bytes -= end - start + 1;
C
Chris Mason 已提交
1206
			BTRFS_I(inode)->delalloc_bytes -= end - start + 1;
C
Chris Mason 已提交
1207
		}
1208 1209 1210 1211
		if (BTRFS_I(inode)->delalloc_bytes == 0 &&
		    !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
			list_del_init(&BTRFS_I(inode)->delalloc_inodes);
		}
1212
		spin_unlock(&root->fs_info->delalloc_lock);
1213 1214 1215 1216
	}
	return 0;
}

C
Chris Mason 已提交
1217 1218 1219 1220
/*
 * 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
 */
1221
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
C
Chris Mason 已提交
1222 1223
			 size_t size, struct bio *bio,
			 unsigned long bio_flags)
1224 1225 1226
{
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct btrfs_mapping_tree *map_tree;
1227
	u64 logical = (u64)bio->bi_sector << 9;
1228 1229 1230 1231
	u64 length = 0;
	u64 map_length;
	int ret;

1232 1233 1234
	if (bio_flags & EXTENT_BIO_COMPRESSED)
		return 0;

1235
	length = bio->bi_size;
1236 1237
	map_tree = &root->fs_info->mapping_tree;
	map_length = length;
1238
	ret = btrfs_map_block(map_tree, READ, logical,
1239
			      &map_length, NULL, 0);
1240

C
Chris Mason 已提交
1241
	if (map_length < length + size)
1242 1243 1244 1245
		return 1;
	return 0;
}

C
Chris Mason 已提交
1246 1247 1248 1249 1250 1251 1252 1253
/*
 * in order to insert checksums into the metadata in large chunks,
 * we wait until bio submission time.   All the pages in the bio are
 * checksummed and sums are attached onto the ordered extent record.
 *
 * At IO completion time the cums attached on the ordered extent record
 * are inserted into the btree
 */
C
Chris Mason 已提交
1254 1255 1256
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
				    unsigned long bio_flags)
1257 1258 1259
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1260

1261
	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1262
	BUG_ON(ret);
C
Chris Mason 已提交
1263 1264
	return 0;
}
1265

C
Chris Mason 已提交
1266 1267 1268 1269 1270 1271 1272 1273
/*
 * 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
 */
1274
static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
1275 1276 1277
			  int mirror_num, unsigned long bio_flags)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1278
	return btrfs_map_bio(root, rw, bio, mirror_num, 1);
1279 1280
}

C
Chris Mason 已提交
1281
/*
1282 1283
 * extent_io.c submission hook. This does the right thing for csum calculation
 * on write, or reading the csums from the tree before a read
C
Chris Mason 已提交
1284
 */
1285
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
1286
			  int mirror_num, unsigned long bio_flags)
1287 1288 1289
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1290
	int skip_sum;
1291

1292 1293
	skip_sum = btrfs_test_flag(inode, NODATASUM);

1294 1295
	ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
	BUG_ON(ret);
1296

1297
	if (!(rw & (1 << BIO_RW))) {
1298
		if (bio_flags & EXTENT_BIO_COMPRESSED) {
C
Chris Mason 已提交
1299 1300
			return btrfs_submit_compressed_read(inode, bio,
						    mirror_num, bio_flags);
1301 1302
		} else if (!skip_sum)
			btrfs_lookup_bio_sums(root, inode, bio, NULL);
1303
		goto mapit;
1304
	} else if (!skip_sum) {
1305 1306 1307
		/* csum items have already been cloned */
		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
			goto mapit;
1308 1309
		/* we're doing a write, do the async checksumming */
		return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1310
				   inode, rw, bio, mirror_num,
C
Chris Mason 已提交
1311 1312
				   bio_flags, __btrfs_submit_bio_start,
				   __btrfs_submit_bio_done);
1313 1314
	}

1315
mapit:
1316
	return btrfs_map_bio(root, rw, bio, mirror_num, 0);
1317
}
C
Chris Mason 已提交
1318

C
Chris Mason 已提交
1319 1320 1321 1322
/*
 * 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.
 */
1323
static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1324 1325 1326 1327 1328 1329
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

	btrfs_set_trans_block_group(trans, inode);
Q
Qinghuang Feng 已提交
1330 1331

	list_for_each_entry(sum, list, list) {
1332 1333
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
1334 1335 1336 1337
	}
	return 0;
}

1338 1339
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end)
{
C
Chris Mason 已提交
1340
	if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
1341
		WARN_ON(1);
1342 1343 1344 1345
	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
				   GFP_NOFS);
}

C
Chris Mason 已提交
1346
/* see btrfs_writepage_start_hook for details on why this is required */
1347 1348 1349 1350 1351
struct btrfs_writepage_fixup {
	struct page *page;
	struct btrfs_work work;
};

1352
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
{
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_ordered_extent *ordered;
	struct page *page;
	struct inode *inode;
	u64 page_start;
	u64 page_end;

	fixup = container_of(work, struct btrfs_writepage_fixup, work);
	page = fixup->page;
C
Chris Mason 已提交
1363
again:
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
	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;

	lock_extent(&BTRFS_I(inode)->io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
1375 1376 1377 1378

	/* already ordered? We're done */
	if (test_range_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
			     EXTENT_ORDERED, 0)) {
1379
		goto out;
C
Chris Mason 已提交
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
	}

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
		unlock_extent(&BTRFS_I(inode)->io_tree, page_start,
			      page_end, GFP_NOFS);
		unlock_page(page);
		btrfs_start_ordered_extent(inode, ordered, 1);
		goto again;
	}
1390

1391
	btrfs_set_extent_delalloc(inode, page_start, page_end);
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	ClearPageChecked(page);
out:
	unlock_extent(&BTRFS_I(inode)->io_tree, page_start, page_end, GFP_NOFS);
out_page:
	unlock_page(page);
	page_cache_release(page);
}

/*
 * There are a few paths in the higher layers of the kernel that directly
 * set the page dirty bit without asking the filesystem if it is a
 * good idea.  This causes problems because we want to make sure COW
 * properly happens and the data=ordered rules are followed.
 *
C
Chris Mason 已提交
1406
 * In our case any range that doesn't have the ORDERED bit set
1407 1408 1409 1410
 * 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.
 */
1411
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
{
	struct inode *inode = page->mapping->host;
	struct btrfs_writepage_fixup *fixup;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;

	ret = test_range_bit(&BTRFS_I(inode)->io_tree, start, end,
			     EXTENT_ORDERED, 0);
	if (ret)
		return 0;

	if (PageChecked(page))
		return -EAGAIN;

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

1430 1431 1432 1433 1434 1435 1436 1437
	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);
	return -EAGAIN;
}

Y
Yan Zheng 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
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();
	BUG_ON(!path);

1456
	path->leave_spinning = 1;
Y
Yan Zheng 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
	ret = btrfs_drop_extents(trans, root, inode, file_pos,
				 file_pos + num_bytes, file_pos, &hint);
	BUG_ON(ret);

	ins.objectid = inode->i_ino;
	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);
1479 1480 1481 1482

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

Y
Yan Zheng 已提交
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
	btrfs_mark_buffer_dirty(leaf);

	inode_add_bytes(inode, num_bytes);
	btrfs_drop_extent_cache(inode, file_pos, file_pos + num_bytes - 1, 0);

	ins.objectid = disk_bytenr;
	ins.offset = disk_num_bytes;
	ins.type = BTRFS_EXTENT_ITEM_KEY;
	ret = btrfs_alloc_reserved_extent(trans, root, leaf->start,
					  root->root_key.objectid,
					  trans->transid, inode->i_ino, &ins);
	BUG_ON(ret);
	btrfs_free_path(path);
1496

Y
Yan Zheng 已提交
1497 1498 1499
	return 0;
}

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
/*
 * 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.
 */
static noinline void reada_csum(struct btrfs_root *root,
				struct btrfs_path *path,
				struct btrfs_ordered_extent *ordered_extent)
{
	struct btrfs_ordered_sum *sum;
	u64 bytenr;

	sum = list_entry(ordered_extent->list.next, struct btrfs_ordered_sum,
			 list);
	bytenr = sum->sums[0].bytenr;

	/*
	 * we don't care about the results, the point of this search is
	 * just to get the btree leaves into ram
	 */
	btrfs_lookup_csum(NULL, root->fs_info->csum_root, path, bytenr, 0);
}

C
Chris Mason 已提交
1524 1525 1526 1527
/* 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.
 */
1528
static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1529 1530 1531
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
1532
	struct btrfs_ordered_extent *ordered_extent = NULL;
1533
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1534
	struct btrfs_path *path;
Y
Yan Zheng 已提交
1535
	int compressed = 0;
1536 1537 1538
	int ret;

	ret = btrfs_dec_test_ordered_pending(inode, start, end - start + 1);
1539
	if (!ret)
1540 1541
		return 0;

1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
	/*
	 * before we join the transaction, try to do some of our IO.
	 * This will limit the amount of IO that we have to do with
	 * the transaction running.  We're unlikely to need to do any
	 * IO if the file extents are new, the disk_i_size checks
	 * covers the most common case.
	 */
	if (start < BTRFS_I(inode)->disk_i_size) {
		path = btrfs_alloc_path();
		if (path) {
			ret = btrfs_lookup_file_extent(NULL, root, path,
						       inode->i_ino,
						       start, 0);
1555 1556 1557 1558 1559 1560
			ordered_extent = btrfs_lookup_ordered_extent(inode,
								     start);
			if (!list_empty(&ordered_extent->list)) {
				btrfs_release_path(root, path);
				reada_csum(root, path, ordered_extent);
			}
1561 1562 1563 1564
			btrfs_free_path(path);
		}
	}

1565
	trans = btrfs_join_transaction(root, 1);
1566

1567 1568
	if (!ordered_extent)
		ordered_extent = btrfs_lookup_ordered_extent(inode, start);
1569
	BUG_ON(!ordered_extent);
1570 1571
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags))
		goto nocow;
1572 1573 1574 1575 1576

	lock_extent(io_tree, ordered_extent->file_offset,
		    ordered_extent->file_offset + ordered_extent->len - 1,
		    GFP_NOFS);

C
Chris Mason 已提交
1577
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
Y
Yan Zheng 已提交
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
		compressed = 1;
	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
		BUG_ON(compressed);
		ret = btrfs_mark_extent_written(trans, root, inode,
						ordered_extent->file_offset,
						ordered_extent->file_offset +
						ordered_extent->len);
		BUG_ON(ret);
	} else {
		ret = insert_reserved_file_extent(trans, inode,
						ordered_extent->file_offset,
						ordered_extent->start,
						ordered_extent->disk_len,
						ordered_extent->len,
						ordered_extent->len,
						compressed, 0, 0,
						BTRFS_FILE_EXTENT_REG);
		BUG_ON(ret);
	}
1597 1598 1599
	unlock_extent(io_tree, ordered_extent->file_offset,
		    ordered_extent->file_offset + ordered_extent->len - 1,
		    GFP_NOFS);
1600
nocow:
1601 1602 1603
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

1604
	mutex_lock(&BTRFS_I(inode)->extent_mutex);
1605
	btrfs_ordered_update_i_size(inode, ordered_extent);
1606
	btrfs_update_inode(trans, root, inode);
1607
	btrfs_remove_ordered_extent(inode, ordered_extent);
1608
	mutex_unlock(&BTRFS_I(inode)->extent_mutex);
1609

1610 1611 1612 1613 1614 1615 1616 1617 1618
	/* once for us */
	btrfs_put_ordered_extent(ordered_extent);
	/* once for the tree */
	btrfs_put_ordered_extent(ordered_extent);

	btrfs_end_transaction(trans, root);
	return 0;
}

1619
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1620 1621 1622 1623 1624
				struct extent_state *state, int uptodate)
{
	return btrfs_finish_ordered_io(page->mapping->host, start, end);
}

C
Chris Mason 已提交
1625 1626 1627 1628 1629 1630 1631 1632
/*
 * When IO fails, either with EIO or csum verification fails, we
 * try other mirrors that might have a good copy of the data.  This
 * io_failure_record is used to record state as we go through all the
 * mirrors.  If another mirror has good data, the page is set up to date
 * and things continue.  If a good mirror can't be found, the original
 * bio end_io callback is called to indicate things have failed.
 */
1633 1634 1635 1636 1637
struct io_failure_record {
	struct page *page;
	u64 start;
	u64 len;
	u64 logical;
1638
	unsigned long bio_flags;
1639 1640 1641
	int last_mirror;
};

1642
static int btrfs_io_failed_hook(struct bio *failed_bio,
1643 1644
			 struct page *page, u64 start, u64 end,
			 struct extent_state *state)
1645 1646 1647 1648 1649 1650
{
	struct io_failure_record *failrec = NULL;
	u64 private;
	struct extent_map *em;
	struct inode *inode = page->mapping->host;
	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
1651
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1652 1653 1654
	struct bio *bio;
	int num_copies;
	int ret;
1655
	int rw;
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
	u64 logical;

	ret = get_state_private(failure_tree, start, &private);
	if (ret) {
		failrec = kmalloc(sizeof(*failrec), GFP_NOFS);
		if (!failrec)
			return -ENOMEM;
		failrec->start = start;
		failrec->len = end - start + 1;
		failrec->last_mirror = 0;
1666
		failrec->bio_flags = 0;
1667

1668 1669 1670 1671 1672 1673 1674
		spin_lock(&em_tree->lock);
		em = lookup_extent_mapping(em_tree, start, failrec->len);
		if (em->start > start || em->start + em->len < start) {
			free_extent_map(em);
			em = NULL;
		}
		spin_unlock(&em_tree->lock);
1675 1676 1677 1678 1679 1680 1681

		if (!em || IS_ERR(em)) {
			kfree(failrec);
			return -EIO;
		}
		logical = start - em->start;
		logical = em->block_start + logical;
1682 1683 1684 1685
		if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
			logical = em->block_start;
			failrec->bio_flags = EXTENT_BIO_COMPRESSED;
		}
1686 1687 1688 1689
		failrec->logical = logical;
		free_extent_map(em);
		set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
				EXTENT_DIRTY, GFP_NOFS);
1690 1691
		set_state_private(failure_tree, start,
				 (u64)(unsigned long)failrec);
1692
	} else {
1693
		failrec = (struct io_failure_record *)(unsigned long)private;
1694 1695 1696 1697 1698 1699
	}
	num_copies = btrfs_num_copies(
			      &BTRFS_I(inode)->root->fs_info->mapping_tree,
			      failrec->logical, failrec->len);
	failrec->last_mirror++;
	if (!state) {
1700
		spin_lock(&BTRFS_I(inode)->io_tree.lock);
1701 1702 1703 1704 1705
		state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
						    failrec->start,
						    EXTENT_LOCKED);
		if (state && state->start != failrec->start)
			state = NULL;
1706
		spin_unlock(&BTRFS_I(inode)->io_tree.lock);
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
	}
	if (!state || failrec->last_mirror > num_copies) {
		set_state_private(failure_tree, failrec->start, 0);
		clear_extent_bits(failure_tree, failrec->start,
				  failrec->start + failrec->len - 1,
				  EXTENT_LOCKED | EXTENT_DIRTY, GFP_NOFS);
		kfree(failrec);
		return -EIO;
	}
	bio = bio_alloc(GFP_NOFS, 1);
	bio->bi_private = state;
	bio->bi_end_io = failed_bio->bi_end_io;
	bio->bi_sector = failrec->logical >> 9;
	bio->bi_bdev = failed_bio->bi_bdev;
1721
	bio->bi_size = 0;
1722

1723
	bio_add_page(bio, page, failrec->len, start - page_offset(page));
1724 1725 1726 1727 1728 1729
	if (failed_bio->bi_rw & (1 << BIO_RW))
		rw = WRITE;
	else
		rw = READ;

	BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
C
Chris Mason 已提交
1730
						      failrec->last_mirror,
1731
						      failrec->bio_flags);
1732 1733 1734
	return 0;
}

C
Chris Mason 已提交
1735 1736 1737 1738
/*
 * each time an IO finishes, we do a fast check in the IO failure tree
 * to see if we need to process or clean up an io_failure_record
 */
1739
static int btrfs_clean_io_failures(struct inode *inode, u64 start)
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
{
	u64 private;
	u64 private_failure;
	struct io_failure_record *failure;
	int ret;

	private = 0;
	if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
			     (u64)-1, 1, EXTENT_DIRTY)) {
		ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
					start, &private_failure);
		if (ret == 0) {
			failure = (struct io_failure_record *)(unsigned long)
				   private_failure;
			set_state_private(&BTRFS_I(inode)->io_failure_tree,
					  failure->start, 0);
			clear_extent_bits(&BTRFS_I(inode)->io_failure_tree,
					  failure->start,
					  failure->start + failure->len - 1,
					  EXTENT_DIRTY | EXTENT_LOCKED,
					  GFP_NOFS);
			kfree(failure);
		}
	}
1764 1765 1766
	return 0;
}

C
Chris Mason 已提交
1767 1768 1769 1770 1771
/*
 * when reads are done, we need to check csums to verify the data is correct
 * if there's a match, we allow the bio to finish.  If not, we go through
 * the io_failure_record routines to find good copies
 */
1772
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1773
			       struct extent_state *state)
1774
{
1775
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1776
	struct inode *inode = page->mapping->host;
1777
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1778
	char *kaddr;
1779
	u64 private = ~(u32)0;
1780
	int ret;
1781 1782
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
1783

1784 1785 1786 1787
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
1788 1789 1790 1791 1792 1793 1794
	if (btrfs_test_flag(inode, NODATASUM))
		return 0;

	if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
	    test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1)) {
		clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
				  GFP_NOFS);
1795
		return 0;
1796
	}
1797

Y
Yan 已提交
1798
	if (state && state->start == start) {
1799 1800 1801 1802 1803
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
1804
	kaddr = kmap_atomic(page, KM_USER0);
C
Chris Mason 已提交
1805
	if (ret)
1806
		goto zeroit;
C
Chris Mason 已提交
1807

1808 1809
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
C
Chris Mason 已提交
1810
	if (csum != private)
1811
		goto zeroit;
C
Chris Mason 已提交
1812

1813
	kunmap_atomic(kaddr, KM_USER0);
1814
good:
1815 1816 1817
	/* if the io failure tree for this inode is non-empty,
	 * check to see if we've recovered from a failed IO
	 */
1818
	btrfs_clean_io_failures(inode, start);
1819 1820 1821
	return 0;

zeroit:
C
Chris Mason 已提交
1822 1823 1824 1825
	printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
	       "private %llu\n", page->mapping->host->i_ino,
	       (unsigned long long)start, csum,
	       (unsigned long long)private);
1826 1827
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
1828
	kunmap_atomic(kaddr, KM_USER0);
1829 1830
	if (private == 0)
		return 0;
1831
	return -EIO;
1832
}
1833

1834 1835 1836 1837 1838 1839 1840 1841 1842
/*
 * This creates an orphan entry for the given inode in case something goes
 * wrong in the middle of an unlink/truncate.
 */
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;

1843
	spin_lock(&root->list_lock);
1844 1845 1846

	/* already on the orphan list, we're good */
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
1847
		spin_unlock(&root->list_lock);
1848 1849 1850 1851 1852
		return 0;
	}

	list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);

1853
	spin_unlock(&root->list_lock);
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871

	/*
	 * insert an orphan item to track this unlinked/truncated file
	 */
	ret = btrfs_insert_orphan_item(trans, root, inode->i_ino);

	return ret;
}

/*
 * 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;
	int ret = 0;

1872
	spin_lock(&root->list_lock);
1873 1874

	if (list_empty(&BTRFS_I(inode)->i_orphan)) {
1875
		spin_unlock(&root->list_lock);
1876 1877 1878 1879 1880
		return 0;
	}

	list_del_init(&BTRFS_I(inode)->i_orphan);
	if (!trans) {
1881
		spin_unlock(&root->list_lock);
1882 1883 1884
		return 0;
	}

1885
	spin_unlock(&root->list_lock);
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 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 1953

	ret = btrfs_del_orphan_item(trans, root, inode->i_ino);

	return ret;
}

/*
 * this cleans up any orphans that may be left on the list from the last use
 * of this root.
 */
void btrfs_orphan_cleanup(struct btrfs_root *root)
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_item *item;
	struct btrfs_key key, found_key;
	struct btrfs_trans_handle *trans;
	struct inode *inode;
	int ret = 0, nr_unlink = 0, nr_truncate = 0;

	path = btrfs_alloc_path();
	if (!path)
		return;
	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);
		if (ret < 0) {
			printk(KERN_ERR "Error searching slot for orphan: %d"
			       "\n", ret);
			break;
		}

		/*
		 * if ret == 0 means we found what we were searching for, which
		 * is weird, but possible, so only screw with path if we didnt
		 * find the key and see if we have stuff that matches
		 */
		if (ret > 0) {
			if (path->slots[0] == 0)
				break;
			path->slots[0]--;
		}

		/* pull out the item */
		leaf = path->nodes[0];
		item = btrfs_item_nr(leaf, path->slots[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 */
		btrfs_release_path(root, path);

		/*
		 * 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.
		 */
1954
		inode = btrfs_iget_locked(root->fs_info->sb,
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974
					  found_key.offset, root);
		if (!inode)
			break;

		if (inode->i_state & I_NEW) {
			BTRFS_I(inode)->root = root;

			/* have to set the location manually */
			BTRFS_I(inode)->location.objectid = inode->i_ino;
			BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
			BTRFS_I(inode)->location.offset = 0;

			btrfs_read_locked_inode(inode);
			unlock_new_inode(inode);
		}

		/*
		 * add this inode to the orphan list so btrfs_orphan_del does
		 * the proper thing when we hit it
		 */
1975
		spin_lock(&root->list_lock);
1976
		list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
1977
		spin_unlock(&root->list_lock);
1978 1979 1980 1981 1982 1983 1984 1985

		/*
		 * if this is a bad inode, means we actually succeeded in
		 * removing the inode, but not the orphan record, which means
		 * we need to manually delete the orphan since iput will just
		 * do a destroy_inode
		 */
		if (is_bad_inode(inode)) {
1986
			trans = btrfs_start_transaction(root, 1);
1987
			btrfs_orphan_del(trans, inode);
1988
			btrfs_end_transaction(trans, root);
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012
			iput(inode);
			continue;
		}

		/* if we have links, this was a truncate, lets do that */
		if (inode->i_nlink) {
			nr_truncate++;
			btrfs_truncate(inode);
		} else {
			nr_unlink++;
		}

		/* this will do delete_inode and everything for us */
		iput(inode);
	}

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

	btrfs_free_path(path);
}

C
Chris Mason 已提交
2013 2014 2015
/*
 * read an inode from the btree into the in-memory inode
 */
C
Chris Mason 已提交
2016 2017 2018
void btrfs_read_locked_inode(struct inode *inode)
{
	struct btrfs_path *path;
2019
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2020
	struct btrfs_inode_item *inode_item;
2021
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
2022 2023 2024
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
	u64 alloc_group_block;
J
Josef Bacik 已提交
2025
	u32 rdev;
C
Chris Mason 已提交
2026 2027 2028 2029 2030
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
C
Chris Mason 已提交
2031

C
Chris Mason 已提交
2032
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2033
	if (ret)
C
Chris Mason 已提交
2034 2035
		goto make_bad;

2036 2037 2038 2039 2040 2041 2042 2043
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_inode_item);

	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
	inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
	inode->i_uid = btrfs_inode_uid(leaf, inode_item);
	inode->i_gid = btrfs_inode_gid(leaf, inode_item);
2044
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057

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

2058
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2059
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2060
	BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2061
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
2062
	inode->i_rdev = 0;
2063 2064
	rdev = btrfs_inode_rdev(leaf, inode_item);

2065
	BTRFS_I(inode)->index_cnt = (u64)-1;
2066
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2067

2068
	alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
2069

2070 2071
	BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
						alloc_group_block, 0);
C
Chris Mason 已提交
2072 2073 2074 2075 2076 2077
	btrfs_free_path(path);
	inode_item = NULL;

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
2078
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2079
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
		break;
	case S_IFDIR:
		inode->i_fop = &btrfs_dir_file_operations;
		if (root == root->fs_info->tree_root)
			inode->i_op = &btrfs_dir_ro_inode_operations;
		else
			inode->i_op = &btrfs_dir_inode_operations;
		break;
	case S_IFLNK:
		inode->i_op = &btrfs_symlink_inode_operations;
		inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
2093
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
2094
		break;
J
Josef Bacik 已提交
2095
	default:
J
Jim Owens 已提交
2096
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
2097 2098
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
2099 2100 2101 2102 2103 2104 2105 2106
	}
	return;

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

C
Chris Mason 已提交
2107 2108 2109
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
2110 2111
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
2112
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
2113 2114
			    struct inode *inode)
{
2115 2116
	btrfs_set_inode_uid(leaf, item, inode->i_uid);
	btrfs_set_inode_gid(leaf, item, inode->i_gid);
2117
	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
	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);

2136
	btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2137
	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2138
	btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2139
	btrfs_set_inode_transid(leaf, item, trans->transid);
2140
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
Y
Yan 已提交
2141
	btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2142
	btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
C
Chris Mason 已提交
2143 2144
}

C
Chris Mason 已提交
2145 2146 2147
/*
 * copy everything in the in-memory inode into the btree.
 */
C
Chris Mason 已提交
2148 2149
noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
2150 2151 2152
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
2153
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2154 2155 2156 2157
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
2158
	path->leave_spinning = 1;
C
Chris Mason 已提交
2159 2160 2161 2162 2163 2164 2165 2166
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, 1);
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

2167
	btrfs_unlock_up_safe(path, 1);
2168 2169
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2170 2171
				  struct btrfs_inode_item);

2172
	fill_inode_item(trans, leaf, inode_item, inode);
2173
	btrfs_mark_buffer_dirty(leaf);
2174
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
2175 2176 2177 2178 2179 2180 2181
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}


C
Chris Mason 已提交
2182 2183 2184 2185 2186
/*
 * 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
 */
2187 2188 2189 2190
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 已提交
2191 2192 2193
{
	struct btrfs_path *path;
	int ret = 0;
2194
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2195
	struct btrfs_dir_item *di;
2196
	struct btrfs_key key;
2197
	u64 index;
C
Chris Mason 已提交
2198 2199

	path = btrfs_alloc_path();
2200 2201 2202 2203 2204
	if (!path) {
		ret = -ENOMEM;
		goto err;
	}

2205
	path->leave_spinning = 1;
C
Chris Mason 已提交
2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
	di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
2216 2217
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
2218
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2219 2220
	if (ret)
		goto err;
C
Chris Mason 已提交
2221 2222
	btrfs_release_path(root, path);

2223
	ret = btrfs_del_inode_ref(trans, root, name, name_len,
2224 2225
				  inode->i_ino,
				  dir->i_ino, &index);
2226
	if (ret) {
C
Chris Mason 已提交
2227
		printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2228
		       "inode %lu parent %lu\n", name_len, name,
2229
		       inode->i_ino, dir->i_ino);
2230 2231 2232
		goto err;
	}

C
Chris Mason 已提交
2233
	di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
2234
					 index, name, name_len, -1);
C
Chris Mason 已提交
2235 2236 2237 2238 2239 2240 2241 2242 2243
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2244
	btrfs_release_path(root, path);
C
Chris Mason 已提交
2245

2246 2247
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
					 inode, dir->i_ino);
C
Chris Mason 已提交
2248
	BUG_ON(ret != 0 && ret != -ENOENT);
2249 2250 2251 2252

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
	BUG_ON(ret);
C
Chris Mason 已提交
2253 2254
err:
	btrfs_free_path(path);
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
	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);
	btrfs_drop_nlink(inode);
	ret = btrfs_update_inode(trans, root, inode);
	dir->i_sb->s_dirt = 1;
out:
C
Chris Mason 已提交
2265 2266 2267 2268 2269 2270 2271
	return ret;
}

static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root;
	struct btrfs_trans_handle *trans;
2272
	struct inode *inode = dentry->d_inode;
C
Chris Mason 已提交
2273
	int ret;
2274
	unsigned long nr = 0;
C
Chris Mason 已提交
2275 2276

	root = BTRFS_I(dir)->root;
2277

C
Chris Mason 已提交
2278
	trans = btrfs_start_transaction(root, 1);
2279

C
Chris Mason 已提交
2280
	btrfs_set_trans_block_group(trans, dir);
2281 2282 2283

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

2284 2285
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
2286 2287 2288 2289

	if (inode->i_nlink == 0)
		ret = btrfs_orphan_add(trans, inode);

2290
	nr = trans->blocks_used;
2291

2292
	btrfs_end_transaction_throttle(trans, root);
2293
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2294 2295 2296 2297 2298 2299
	return ret;
}

static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
2300
	int err = 0;
C
Chris Mason 已提交
2301 2302 2303
	int ret;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
2304
	unsigned long nr = 0;
C
Chris Mason 已提交
2305

2306 2307 2308 2309 2310 2311
	/*
	 * the FIRST_FREE_OBJECTID check makes sure we don't try to rmdir
	 * the root of a subvolume or snapshot
	 */
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
	    inode->i_ino == BTRFS_FIRST_FREE_OBJECTID) {
Y
Yan 已提交
2312
		return -ENOTEMPTY;
2313
	}
Y
Yan 已提交
2314

C
Chris Mason 已提交
2315 2316 2317
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

2318 2319 2320 2321
	err = btrfs_orphan_add(trans, inode);
	if (err)
		goto fail_trans;

C
Chris Mason 已提交
2322
	/* now the directory is empty */
2323 2324
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
C
Chris Mason 已提交
2325
	if (!err)
2326
		btrfs_i_size_write(inode, 0);
2327

2328
fail_trans:
2329
	nr = trans->blocks_used;
2330
	ret = btrfs_end_transaction_throttle(trans, root);
2331
	btrfs_btree_balance_dirty(root, nr);
2332

C
Chris Mason 已提交
2333 2334 2335 2336 2337
	if (ret && !err)
		err = ret;
	return err;
}

2338
#if 0
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
/*
 * when truncating bytes in a file, it is possible to avoid reading
 * the leaves that contain only checksum items.  This can be the
 * majority of the IO required to delete a large file, but it must
 * be done carefully.
 *
 * The keys in the level just above the leaves are checked to make sure
 * the lowest key in a given leaf is a csum key, and starts at an offset
 * after the new  size.
 *
 * Then the key for the next leaf is checked to make sure it also has
 * a checksum item for the same file.  If it does, we know our target leaf
 * contains only checksum items, and it can be safely freed without reading
 * it.
 *
 * This is just an optimization targeted at large files.  It may do
 * nothing.  It will return 0 unless things went badly.
 */
static noinline int drop_csum_leaves(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     struct btrfs_path *path,
				     struct inode *inode, u64 new_size)
{
	struct btrfs_key key;
	int ret;
	int nritems;
	struct btrfs_key found_key;
	struct btrfs_key other_key;
Y
Yan Zheng 已提交
2367 2368 2369
	struct btrfs_leaf_ref *ref;
	u64 leaf_gen;
	u64 leaf_start;
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462

	path->lowest_level = 1;
	key.objectid = inode->i_ino;
	key.type = BTRFS_CSUM_ITEM_KEY;
	key.offset = new_size;
again:
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret < 0)
		goto out;

	if (path->nodes[1] == NULL) {
		ret = 0;
		goto out;
	}
	ret = 0;
	btrfs_node_key_to_cpu(path->nodes[1], &found_key, path->slots[1]);
	nritems = btrfs_header_nritems(path->nodes[1]);

	if (!nritems)
		goto out;

	if (path->slots[1] >= nritems)
		goto next_node;

	/* did we find a key greater than anything we want to delete? */
	if (found_key.objectid > inode->i_ino ||
	   (found_key.objectid == inode->i_ino && found_key.type > key.type))
		goto out;

	/* we check the next key in the node to make sure the leave contains
	 * only checksum items.  This comparison doesn't work if our
	 * leaf is the last one in the node
	 */
	if (path->slots[1] + 1 >= nritems) {
next_node:
		/* search forward from the last key in the node, this
		 * will bring us into the next node in the tree
		 */
		btrfs_node_key_to_cpu(path->nodes[1], &found_key, nritems - 1);

		/* unlikely, but we inc below, so check to be safe */
		if (found_key.offset == (u64)-1)
			goto out;

		/* search_forward needs a path with locks held, do the
		 * search again for the original key.  It is possible
		 * this will race with a balance and return a path that
		 * we could modify, but this drop is just an optimization
		 * and is allowed to miss some leaves.
		 */
		btrfs_release_path(root, path);
		found_key.offset++;

		/* setup a max key for search_forward */
		other_key.offset = (u64)-1;
		other_key.type = key.type;
		other_key.objectid = key.objectid;

		path->keep_locks = 1;
		ret = btrfs_search_forward(root, &found_key, &other_key,
					   path, 0, 0);
		path->keep_locks = 0;
		if (ret || found_key.objectid != key.objectid ||
		    found_key.type != key.type) {
			ret = 0;
			goto out;
		}

		key.offset = found_key.offset;
		btrfs_release_path(root, path);
		cond_resched();
		goto again;
	}

	/* we know there's one more slot after us in the tree,
	 * read that key so we can verify it is also a checksum item
	 */
	btrfs_node_key_to_cpu(path->nodes[1], &other_key, path->slots[1] + 1);

	if (found_key.objectid < inode->i_ino)
		goto next_key;

	if (found_key.type != key.type || found_key.offset < new_size)
		goto next_key;

	/*
	 * if the key for the next leaf isn't a csum key from this objectid,
	 * we can't be sure there aren't good items inside this leaf.
	 * Bail out
	 */
	if (other_key.objectid != inode->i_ino || other_key.type != key.type)
		goto out;

Y
Yan Zheng 已提交
2463 2464
	leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);
	leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);
2465 2466 2467 2468
	/*
	 * it is safe to delete this leaf, it contains only
	 * csum items from this inode at an offset >= new_size
	 */
Y
Yan Zheng 已提交
2469
	ret = btrfs_del_leaf(trans, root, path, leaf_start);
2470 2471
	BUG_ON(ret);

Y
Yan Zheng 已提交
2472 2473 2474 2475 2476 2477 2478 2479 2480
	if (root->ref_cows && leaf_gen < trans->transid) {
		ref = btrfs_alloc_leaf_ref(root, 0);
		if (ref) {
			ref->root_gen = root->root_key.offset;
			ref->bytenr = leaf_start;
			ref->owner = 0;
			ref->generation = leaf_gen;
			ref->nritems = 0;

2481 2482
			btrfs_sort_leaf_ref(ref);

Y
Yan Zheng 已提交
2483 2484 2485 2486 2487 2488 2489
			ret = btrfs_add_leaf_ref(root, ref, 0);
			WARN_ON(ret);
			btrfs_free_leaf_ref(root, ref);
		} else {
			WARN_ON(1);
		}
	}
2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507
next_key:
	btrfs_release_path(root, path);

	if (other_key.objectid == inode->i_ino &&
	    other_key.type == key.type && other_key.offset > key.offset) {
		key.offset = other_key.offset;
		cond_resched();
		goto again;
	}
	ret = 0;
out:
	/* fixup any changes we've made to the path */
	path->lowest_level = 0;
	path->keep_locks = 0;
	btrfs_release_path(root, path);
	return ret;
}

2508 2509
#endif

C
Chris Mason 已提交
2510 2511 2512
/*
 * this can truncate away extent items, csum items and directory items.
 * It starts at a high offset and removes keys until it can't find
C
Chris Mason 已提交
2513
 * any higher than new_size
C
Chris Mason 已提交
2514 2515 2516
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
2517 2518 2519
 *
 * 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 已提交
2520
 */
2521 2522 2523 2524
noinline 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 已提交
2525 2526 2527 2528
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;
2529
	struct btrfs_key found_key;
2530
	u32 found_type = (u8)-1;
2531
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2532 2533
	struct btrfs_file_extent_item *fi;
	u64 extent_start = 0;
2534
	u64 extent_num_bytes = 0;
C
Chris Mason 已提交
2535
	u64 item_end = 0;
2536
	u64 root_gen = 0;
2537
	u64 root_owner = 0;
C
Chris Mason 已提交
2538 2539
	int found_extent;
	int del_item;
2540 2541
	int pending_del_nr = 0;
	int pending_del_slot = 0;
2542
	int extent_type = -1;
2543
	int encoding;
2544
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
2545

2546
	if (root->ref_cows)
2547
		btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
C
Chris Mason 已提交
2548
	path = btrfs_alloc_path();
2549
	path->reada = -1;
C
Chris Mason 已提交
2550
	BUG_ON(!path);
2551

C
Chris Mason 已提交
2552 2553 2554
	/* FIXME, add redo link to tree so we don't leak on crash */
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
2555 2556
	key.type = (u8)-1;

2557
search_again:
2558
	path->leave_spinning = 1;
2559
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
C
Chris Mason 已提交
2560
	if (ret < 0)
2561
		goto error;
C
Chris Mason 已提交
2562

2563
	if (ret > 0) {
2564 2565 2566 2567 2568 2569 2570
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
		if (path->slots[0] == 0) {
			ret = 0;
			goto error;
		}
2571 2572 2573
		path->slots[0]--;
	}

C
Chris Mason 已提交
2574
	while (1) {
C
Chris Mason 已提交
2575
		fi = NULL;
2576 2577 2578
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		found_type = btrfs_key_type(&found_key);
2579
		encoding = 0;
C
Chris Mason 已提交
2580

2581
		if (found_key.objectid != inode->i_ino)
C
Chris Mason 已提交
2582
			break;
2583

2584
		if (found_type < min_type)
C
Chris Mason 已提交
2585 2586
			break;

2587
		item_end = found_key.offset;
C
Chris Mason 已提交
2588
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
2589
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2590
					    struct btrfs_file_extent_item);
2591
			extent_type = btrfs_file_extent_type(leaf, fi);
2592 2593 2594 2595
			encoding = btrfs_file_extent_compression(leaf, fi);
			encoding |= btrfs_file_extent_encryption(leaf, fi);
			encoding |= btrfs_file_extent_other_encoding(leaf, fi);

2596
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
2597
				item_end +=
2598
				    btrfs_file_extent_num_bytes(leaf, fi);
2599 2600
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
C
Chris Mason 已提交
2601
									 fi);
C
Chris Mason 已提交
2602
			}
2603
			item_end--;
C
Chris Mason 已提交
2604
		}
2605
		if (item_end < new_size) {
C
Chris Mason 已提交
2606
			if (found_type == BTRFS_DIR_ITEM_KEY)
2607
				found_type = BTRFS_INODE_ITEM_KEY;
C
Chris Mason 已提交
2608
			else if (found_type == BTRFS_EXTENT_ITEM_KEY)
2609
				found_type = BTRFS_EXTENT_DATA_KEY;
C
Chris Mason 已提交
2610
			else if (found_type == BTRFS_EXTENT_DATA_KEY)
2611
				found_type = BTRFS_XATTR_ITEM_KEY;
C
Chris Mason 已提交
2612
			else if (found_type == BTRFS_XATTR_ITEM_KEY)
2613
				found_type = BTRFS_INODE_REF_KEY;
C
Chris Mason 已提交
2614
			else if (found_type)
2615
				found_type--;
C
Chris Mason 已提交
2616
			else
2617
				break;
2618
			btrfs_set_key_type(&key, found_type);
2619
			goto next;
C
Chris Mason 已提交
2620
		}
2621
		if (found_key.offset >= new_size)
C
Chris Mason 已提交
2622 2623 2624 2625 2626 2627
			del_item = 1;
		else
			del_item = 0;
		found_extent = 0;

		/* FIXME, shrink the extent if the ref count is only 1 */
2628 2629 2630 2631
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2632
			u64 num_dec;
2633
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
2634
			if (!del_item && !encoding) {
2635 2636
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
2637
				extent_num_bytes = new_size -
2638
					found_key.offset + root->sectorsize - 1;
2639 2640
				extent_num_bytes = extent_num_bytes &
					~((u64)root->sectorsize - 1);
2641 2642 2643
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
C
Chris Mason 已提交
2644
					   extent_num_bytes);
2645
				if (root->ref_cows && extent_start != 0)
2646
					inode_sub_bytes(inode, num_dec);
2647
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2648
			} else {
2649 2650 2651
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
C
Chris Mason 已提交
2652
				/* FIXME blocksize != 4096 */
C
Chris Mason 已提交
2653
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
2654 2655
				if (extent_start != 0) {
					found_extent = 1;
2656
					if (root->ref_cows)
2657
						inode_sub_bytes(inode, num_dec);
2658
				}
Z
Zheng Yan 已提交
2659
				root_gen = btrfs_header_generation(leaf);
2660
				root_owner = btrfs_header_owner(leaf);
C
Chris Mason 已提交
2661
			}
C
Chris Mason 已提交
2662
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2663 2664 2665 2666 2667 2668 2669 2670
			/*
			 * 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) {
2671 2672 2673
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
2674 2675
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
2676 2677 2678
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
C
Chris Mason 已提交
2679
				ret = btrfs_truncate_item(trans, root, path,
2680
							  size, 1);
C
Chris Mason 已提交
2681
				BUG_ON(ret);
2682
			} else if (root->ref_cows) {
2683 2684
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
C
Chris Mason 已提交
2685
			}
C
Chris Mason 已提交
2686
		}
2687
delete:
C
Chris Mason 已提交
2688
		if (del_item) {
2689 2690 2691 2692 2693 2694 2695 2696 2697 2698
			if (!pending_del_nr) {
				/* no pending yet, add ourselves */
				pending_del_slot = path->slots[0];
				pending_del_nr = 1;
			} else if (pending_del_nr &&
				   path->slots[0] + 1 == pending_del_slot) {
				/* hop on the pending chunk */
				pending_del_nr++;
				pending_del_slot = path->slots[0];
			} else {
C
Chris Mason 已提交
2699
				BUG();
2700
			}
C
Chris Mason 已提交
2701 2702 2703 2704
		} else {
			break;
		}
		if (found_extent) {
2705
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
2706
			ret = btrfs_free_extent(trans, root, extent_start,
2707
						extent_num_bytes,
Z
Zheng Yan 已提交
2708
						leaf->start, root_owner,
2709
						root_gen, inode->i_ino, 0);
C
Chris Mason 已提交
2710 2711
			BUG_ON(ret);
		}
2712 2713 2714 2715 2716
next:
		if (path->slots[0] == 0) {
			if (pending_del_nr)
				goto del_pending;
			btrfs_release_path(root, path);
2717 2718
			if (found_type == BTRFS_INODE_ITEM_KEY)
				break;
2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
			goto search_again;
		}

		path->slots[0]--;
		if (pending_del_nr &&
		    path->slots[0] + 1 != pending_del_slot) {
			struct btrfs_key debug;
del_pending:
			btrfs_item_key_to_cpu(path->nodes[0], &debug,
					      pending_del_slot);
			ret = btrfs_del_items(trans, root, path,
					      pending_del_slot,
					      pending_del_nr);
			BUG_ON(ret);
			pending_del_nr = 0;
			btrfs_release_path(root, path);
2735 2736
			if (found_type == BTRFS_INODE_ITEM_KEY)
				break;
2737 2738
			goto search_again;
		}
C
Chris Mason 已提交
2739 2740 2741
	}
	ret = 0;
error:
2742 2743 2744 2745
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
	}
C
Chris Mason 已提交
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
	btrfs_free_path(path);
	inode->i_sb->s_dirt = 1;
	return ret;
}

/*
 * 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;
2758
	struct btrfs_root *root = BTRFS_I(inode)->root;
2759 2760 2761
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
	char *kaddr;
2762
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
2763 2764 2765 2766
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
	int ret = 0;
2767
	u64 page_start;
2768
	u64 page_end;
C
Chris Mason 已提交
2769 2770 2771 2772 2773

	if ((offset & (blocksize - 1)) == 0)
		goto out;

	ret = -ENOMEM;
2774
again:
C
Chris Mason 已提交
2775 2776 2777
	page = grab_cache_page(mapping, index);
	if (!page)
		goto out;
2778 2779 2780 2781

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

C
Chris Mason 已提交
2782
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
2783
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
2784
		lock_page(page);
2785 2786 2787 2788 2789
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
2790 2791
		if (!PageUptodate(page)) {
			ret = -EIO;
2792
			goto out_unlock;
C
Chris Mason 已提交
2793 2794
		}
	}
2795
	wait_on_page_writeback(page);
2796 2797 2798 2799 2800 2801 2802 2803 2804

	lock_extent(io_tree, page_start, page_end, GFP_NOFS);
	set_page_extent_mapped(page);

	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
		unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
		unlock_page(page);
		page_cache_release(page);
2805
		btrfs_start_ordered_extent(inode, ordered, 1);
2806 2807 2808 2809
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

2810
	btrfs_set_extent_delalloc(inode, page_start, page_end);
2811 2812 2813 2814 2815 2816 2817
	ret = 0;
	if (offset != PAGE_CACHE_SIZE) {
		kaddr = kmap(page);
		memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
		flush_dcache_page(page);
		kunmap(page);
	}
2818
	ClearPageChecked(page);
2819 2820
	set_page_dirty(page);
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
2821

2822
out_unlock:
C
Chris Mason 已提交
2823 2824 2825 2826 2827 2828
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

Y
Yan Zheng 已提交
2829
int btrfs_cont_expand(struct inode *inode, loff_t size)
C
Chris Mason 已提交
2830
{
Y
Yan Zheng 已提交
2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_map *em;
	u64 mask = root->sectorsize - 1;
	u64 hole_start = (inode->i_size + mask) & ~mask;
	u64 block_end = (size + mask) & ~mask;
	u64 last_byte;
	u64 cur_offset;
	u64 hole_size;
C
Chris Mason 已提交
2841 2842
	int err;

Y
Yan Zheng 已提交
2843 2844 2845
	if (size <= hole_start)
		return 0;

J
Josef Bacik 已提交
2846
	err = btrfs_check_metadata_free_space(root);
C
Chris Mason 已提交
2847 2848 2849
	if (err)
		return err;

Y
Yan Zheng 已提交
2850
	btrfs_truncate_page(inode->i_mapping, inode->i_size);
C
Chris Mason 已提交
2851

Y
Yan Zheng 已提交
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862
	while (1) {
		struct btrfs_ordered_extent *ordered;
		btrfs_wait_ordered_range(inode, hole_start,
					 block_end - hole_start);
		lock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
		ordered = btrfs_lookup_ordered_extent(inode, hole_start);
		if (!ordered)
			break;
		unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
		btrfs_put_ordered_extent(ordered);
	}
C
Chris Mason 已提交
2863

Y
Yan Zheng 已提交
2864 2865
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
C
Chris Mason 已提交
2866

Y
Yan Zheng 已提交
2867 2868 2869 2870 2871 2872 2873 2874
	cur_offset = hole_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				block_end - cur_offset, 0);
		BUG_ON(IS_ERR(em) || !em);
		last_byte = min(extent_map_end(em), block_end);
		last_byte = (last_byte + mask) & ~mask;
		if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) {
2875
			u64 hint_byte = 0;
Y
Yan Zheng 已提交
2876
			hole_size = last_byte - cur_offset;
2877 2878 2879 2880 2881 2882
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
						 cur_offset + hole_size,
						 cur_offset, &hint_byte);
			if (err)
				break;
Y
Yan Zheng 已提交
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
			err = btrfs_insert_file_extent(trans, root,
					inode->i_ino, cur_offset, 0,
					0, hole_size, 0, hole_size,
					0, 0, 0);
			btrfs_drop_extent_cache(inode, hole_start,
					last_byte - 1, 0);
		}
		free_extent_map(em);
		cur_offset = last_byte;
		if (err || cur_offset >= block_end)
			break;
	}
2895

Y
Yan Zheng 已提交
2896 2897 2898 2899
	btrfs_end_transaction(trans, root);
	unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
	return err;
}
C
Chris Mason 已提交
2900

Y
Yan Zheng 已提交
2901 2902 2903 2904
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int err;
C
Chris Mason 已提交
2905

Y
Yan Zheng 已提交
2906 2907 2908
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
2909

2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
		if (attr->ia_size > inode->i_size) {
			err = btrfs_cont_expand(inode, attr->ia_size);
			if (err)
				return err;
		} else if (inode->i_size > 0 &&
			   attr->ia_size == 0) {

			/* 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.
			 */
			BTRFS_I(inode)->ordered_data_close = 1;
		}
C
Chris Mason 已提交
2925
	}
Y
Yan Zheng 已提交
2926

C
Chris Mason 已提交
2927
	err = inode_setattr(inode, attr);
J
Josef Bacik 已提交
2928 2929 2930

	if (!err && ((attr->ia_valid & ATTR_MODE)))
		err = btrfs_acl_chmod(inode);
C
Chris Mason 已提交
2931 2932
	return err;
}
2933

C
Chris Mason 已提交
2934 2935 2936 2937
void btrfs_delete_inode(struct inode *inode)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
2938
	unsigned long nr;
C
Chris Mason 已提交
2939 2940 2941 2942
	int ret;

	truncate_inode_pages(&inode->i_data, 0);
	if (is_bad_inode(inode)) {
2943
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
2944 2945
		goto no_delete;
	}
C
Chris Mason 已提交
2946
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
2947

2948
	btrfs_i_size_write(inode, 0);
2949
	trans = btrfs_join_transaction(root, 1);
2950

C
Chris Mason 已提交
2951
	btrfs_set_trans_block_group(trans, inode);
2952
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size, 0);
2953 2954
	if (ret) {
		btrfs_orphan_del(NULL, inode);
2955
		goto no_delete_lock;
2956 2957 2958
	}

	btrfs_orphan_del(trans, inode);
2959

2960
	nr = trans->blocks_used;
2961
	clear_inode(inode);
2962

C
Chris Mason 已提交
2963
	btrfs_end_transaction(trans, root);
2964
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2965
	return;
2966 2967

no_delete_lock:
2968
	nr = trans->blocks_used;
2969
	btrfs_end_transaction(trans, root);
2970
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
no_delete:
	clear_inode(inode);
}

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

	path = btrfs_alloc_path();
	BUG_ON(!path);
2991

C
Chris Mason 已提交
2992 2993
	di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
				    namelen, 0);
Y
Yan 已提交
2994 2995
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
2996 2997

	if (!di || IS_ERR(di))
2998
		goto out_err;
C
Chris Mason 已提交
2999

3000
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
3001 3002 3003
out:
	btrfs_free_path(path);
	return ret;
3004 3005 3006
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
3007 3008 3009 3010 3011 3012 3013 3014 3015
}

/*
 * 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,
			     struct btrfs_key *location,
3016 3017
			     struct btrfs_root **sub_root,
			     struct dentry *dentry)
C
Chris Mason 已提交
3018 3019 3020 3021 3022 3023 3024 3025
{
	struct btrfs_root_item *ri;

	if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
		return 0;
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return 0;

3026 3027 3028
	*sub_root = btrfs_read_fs_root(root->fs_info, location,
					dentry->d_name.name,
					dentry->d_name.len);
C
Chris Mason 已提交
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
	if (IS_ERR(*sub_root))
		return PTR_ERR(*sub_root);

	ri = &(*sub_root)->root_item;
	location->objectid = btrfs_root_dirid(ri);
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
	location->offset = 0;

	return 0;
}

3040
static noinline void init_btrfs_i(struct inode *inode)
C
Chris Mason 已提交
3041
{
3042 3043 3044 3045 3046 3047
	struct btrfs_inode *bi = BTRFS_I(inode);

	bi->i_acl = NULL;
	bi->i_default_acl = NULL;

	bi->generation = 0;
3048
	bi->sequence = 0;
3049 3050 3051
	bi->last_trans = 0;
	bi->logged_trans = 0;
	bi->delalloc_bytes = 0;
J
Josef Bacik 已提交
3052
	bi->reserved_bytes = 0;
3053 3054 3055
	bi->disk_i_size = 0;
	bi->flags = 0;
	bi->index_cnt = (u64)-1;
3056
	bi->last_unlink_trans = 0;
3057 3058
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
	extent_io_tree_init(&BTRFS_I(inode)->io_tree,
3059
			     inode->i_mapping, GFP_NOFS);
3060 3061
	extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
			     inode->i_mapping, GFP_NOFS);
3062
	INIT_LIST_HEAD(&BTRFS_I(inode)->delalloc_inodes);
3063
	INIT_LIST_HEAD(&BTRFS_I(inode)->ordered_operations);
3064
	btrfs_ordered_inode_tree_init(&BTRFS_I(inode)->ordered_tree);
3065
	mutex_init(&BTRFS_I(inode)->extent_mutex);
3066 3067 3068 3069 3070 3071 3072 3073 3074
	mutex_init(&BTRFS_I(inode)->log_mutex);
}

static int btrfs_init_locked_inode(struct inode *inode, void *p)
{
	struct btrfs_iget_args *args = p;
	inode->i_ino = args->ino;
	init_btrfs_i(inode);
	BTRFS_I(inode)->root = args->root;
J
Josef Bacik 已提交
3075
	btrfs_set_inode_space_info(args->root, inode);
C
Chris Mason 已提交
3076 3077 3078 3079 3080 3081
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
C
Chris Mason 已提交
3082 3083
	return args->ino == inode->i_ino &&
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
3084 3085
}

3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103
struct inode *btrfs_ilookup(struct super_block *s, u64 objectid,
			    struct btrfs_root *root, int wait)
{
	struct inode *inode;
	struct btrfs_iget_args args;
	args.ino = objectid;
	args.root = root;

	if (wait) {
		inode = ilookup5(s, objectid, btrfs_find_actor,
				 (void *)&args);
	} else {
		inode = ilookup5_nowait(s, objectid, btrfs_find_actor,
					(void *)&args);
	}
	return inode;
}

C
Chris Mason 已提交
3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
				struct btrfs_root *root)
{
	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 已提交
3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
/* 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,
			 struct btrfs_root *root, int *is_new)
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
		return ERR_PTR(-EACCES);

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
		unlock_new_inode(inode);
		if (is_new)
			*is_new = 1;
	} else {
		if (is_new)
			*is_new = 0;
	}

	return inode;
}

3145
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
3146
{
C
Chris Mason 已提交
3147
	struct inode *inode;
C
Chris Mason 已提交
3148 3149 3150 3151
	struct btrfs_inode *bi = BTRFS_I(dir);
	struct btrfs_root *root = bi->root;
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
Y
Yan Zheng 已提交
3152
	int ret, new;
C
Chris Mason 已提交
3153 3154 3155

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

C
Chris Mason 已提交
3157
	ret = btrfs_inode_by_name(dir, dentry, &location);
3158

C
Chris Mason 已提交
3159 3160
	if (ret < 0)
		return ERR_PTR(ret);
3161

C
Chris Mason 已提交
3162 3163
	inode = NULL;
	if (location.objectid) {
3164 3165
		ret = fixup_tree_root_location(root, &location, &sub_root,
						dentry);
C
Chris Mason 已提交
3166 3167 3168 3169
		if (ret < 0)
			return ERR_PTR(ret);
		if (ret > 0)
			return ERR_PTR(-ENOENT);
B
Balaji Rao 已提交
3170 3171 3172
		inode = btrfs_iget(dir->i_sb, &location, sub_root, &new);
		if (IS_ERR(inode))
			return ERR_CAST(inode);
C
Chris Mason 已提交
3173
	}
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187
	return inode;
}

static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
				   struct nameidata *nd)
{
	struct inode *inode;

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

	inode = btrfs_lookup_dentry(dir, dentry);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
3188

C
Chris Mason 已提交
3189 3190 3191 3192 3193 3194 3195
	return d_splice_alias(inode, dentry);
}

static unsigned char btrfs_filetype_table[] = {
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

3196 3197
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
3198
{
3199
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
3200 3201 3202 3203
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
3204
	struct btrfs_key found_key;
C
Chris Mason 已提交
3205 3206 3207
	struct btrfs_path *path;
	int ret;
	u32 nritems;
3208
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3209 3210 3211 3212 3213 3214 3215 3216
	int slot;
	int advance;
	unsigned char d_type;
	int over = 0;
	u32 di_cur;
	u32 di_total;
	u32 di_len;
	int key_type = BTRFS_DIR_INDEX_KEY;
3217 3218 3219
	char tmp_name[32];
	char *name_ptr;
	int name_len;
C
Chris Mason 已提交
3220 3221 3222 3223

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

3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
	/* special case for "." */
	if (filp->f_pos == 0) {
		over = filldir(dirent, ".", 1,
			       1, inode->i_ino,
			       DT_DIR);
		if (over)
			return 0;
		filp->f_pos = 1;
	}
	/* special case for .., just use the back ref */
	if (filp->f_pos == 1) {
3236
		u64 pino = parent_ino(filp->f_path.dentry);
3237
		over = filldir(dirent, "..", 2,
3238
			       2, pino, DT_DIR);
3239
		if (over)
3240
			return 0;
3241 3242
		filp->f_pos = 2;
	}
3243 3244 3245
	path = btrfs_alloc_path();
	path->reada = 2;

C
Chris Mason 已提交
3246 3247
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
3248
	key.objectid = inode->i_ino;
3249

C
Chris Mason 已提交
3250 3251 3252 3253
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
	advance = 0;
3254 3255

	while (1) {
3256 3257
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3258 3259
		slot = path->slots[0];
		if (advance || slot >= nritems) {
3260
			if (slot >= nritems - 1) {
C
Chris Mason 已提交
3261 3262 3263
				ret = btrfs_next_leaf(root, path);
				if (ret)
					break;
3264 3265
				leaf = path->nodes[0];
				nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3266 3267 3268 3269 3270 3271
				slot = path->slots[0];
			} else {
				slot++;
				path->slots[0]++;
			}
		}
3272

C
Chris Mason 已提交
3273
		advance = 1;
3274 3275 3276 3277
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
3278
			break;
3279
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
3280
			break;
3281
		if (found_key.offset < filp->f_pos)
C
Chris Mason 已提交
3282
			continue;
3283 3284

		filp->f_pos = found_key.offset;
3285

C
Chris Mason 已提交
3286 3287
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
3288
		di_total = btrfs_item_size(leaf, item);
3289 3290

		while (di_cur < di_total) {
3291 3292 3293
			struct btrfs_key location;

			name_len = btrfs_dir_name_len(leaf, di);
3294
			if (name_len <= sizeof(tmp_name)) {
3295 3296 3297
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
3298 3299 3300 3301
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
3302 3303 3304 3305 3306 3307
			}
			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);
3308 3309 3310 3311 3312 3313 3314 3315 3316

			/* 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;
			}
3317
			over = filldir(dirent, name_ptr, name_len,
3318
				       found_key.offset, location.objectid,
C
Chris Mason 已提交
3319
				       d_type);
3320

3321
skip:
3322 3323 3324
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
3325 3326
			if (over)
				goto nopos;
J
Josef Bacik 已提交
3327
			di_len = btrfs_dir_name_len(leaf, di) +
3328
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
3329 3330 3331 3332
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
	}
3333 3334

	/* Reached end of directory/root. Bump pos past the last item. */
3335
	if (key_type == BTRFS_DIR_INDEX_KEY)
3336
		filp->f_pos = INT_LIMIT(off_t);
3337 3338
	else
		filp->f_pos++;
C
Chris Mason 已提交
3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351
nopos:
	ret = 0;
err:
	btrfs_free_path(path);
	return ret;
}

int btrfs_write_inode(struct inode *inode, int wait)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;

Y
Yan Zheng 已提交
3352
	if (root->fs_info->btree_inode == inode)
3353 3354
		return 0;

C
Chris Mason 已提交
3355
	if (wait) {
3356
		trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3357 3358 3359 3360 3361 3362 3363
		btrfs_set_trans_block_group(trans, inode);
		ret = btrfs_commit_transaction(trans, root);
	}
	return ret;
}

/*
3364
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
3365 3366 3367 3368 3369 3370 3371 3372 3373
 * 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.
 */
void btrfs_dirty_inode(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;

3374
	trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3375 3376 3377 3378 3379
	btrfs_set_trans_block_group(trans, inode);
	btrfs_update_inode(trans, root, inode);
	btrfs_end_transaction(trans, root);
}

C
Chris Mason 已提交
3380 3381 3382 3383 3384
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436
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;

	key.objectid = inode->i_ino;
	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]);

	if (found_key.objectid != inode->i_ino ||
	    btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
		BTRFS_I(inode)->index_cnt = 2;
		goto out;
	}

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

C
Chris Mason 已提交
3437 3438 3439 3440
/*
 * 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
 */
3441
int btrfs_set_inode_index(struct inode *dir, u64 *index)
3442 3443 3444 3445 3446
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
		ret = btrfs_set_inode_index_count(dir);
C
Chris Mason 已提交
3447
		if (ret)
3448 3449 3450
			return ret;
	}

3451
	*index = BTRFS_I(dir)->index_cnt;
3452 3453 3454 3455 3456
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
3457 3458
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
3459
				     struct inode *dir,
3460
				     const char *name, int name_len,
3461 3462
				     u64 ref_objectid, u64 objectid,
				     u64 alloc_hint, int mode, u64 *index)
C
Chris Mason 已提交
3463 3464
{
	struct inode *inode;
3465
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
3466
	struct btrfs_key *location;
3467
	struct btrfs_path *path;
3468 3469 3470 3471
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
3472 3473 3474
	int ret;
	int owner;

3475 3476 3477
	path = btrfs_alloc_path();
	BUG_ON(!path);

C
Chris Mason 已提交
3478 3479 3480 3481
	inode = new_inode(root->fs_info->sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

3482
	if (dir) {
3483
		ret = btrfs_set_inode_index(dir, index);
3484 3485
		if (ret) {
			iput(inode);
3486
			return ERR_PTR(ret);
3487
		}
3488 3489 3490 3491 3492 3493
	}
	/*
	 * index_cnt is ignored for everything but a dir,
	 * btrfs_get_inode_index_count has an explanation for the magic
	 * number
	 */
3494
	init_btrfs_i(inode);
3495
	BTRFS_I(inode)->index_cnt = 2;
C
Chris Mason 已提交
3496
	BTRFS_I(inode)->root = root;
3497
	BTRFS_I(inode)->generation = trans->transid;
J
Josef Bacik 已提交
3498
	btrfs_set_inode_space_info(root, inode);
3499

C
Chris Mason 已提交
3500 3501 3502 3503
	if (mode & S_IFDIR)
		owner = 0;
	else
		owner = 1;
3504 3505
	BTRFS_I(inode)->block_group =
			btrfs_find_block_group(root, 0, alloc_hint, owner);
3506 3507 3508 3509 3510 3511
	if ((mode & S_IFREG)) {
		if (btrfs_test_opt(root, NODATASUM))
			btrfs_set_flag(inode, NODATASUM);
		if (btrfs_test_opt(root, NODATACOW))
			btrfs_set_flag(inode, NODATACOW);
	}
3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523

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

3524
	path->leave_spinning = 1;
3525 3526
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
3527 3528
		goto fail;

3529 3530 3531
	if (objectid > root->highest_inode)
		root->highest_inode = objectid;

C
Chris Mason 已提交
3532
	inode->i_uid = current_fsuid();
3533

3534
	if (dir && (dir->i_mode & S_ISGID)) {
3535 3536 3537 3538 3539 3540
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current_fsgid();

C
Chris Mason 已提交
3541 3542
	inode->i_mode = mode;
	inode->i_ino = objectid;
3543
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
3544
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
3545 3546
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
3547
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
3548 3549 3550 3551

	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);
3552
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
3553 3554 3555
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

3556 3557 3558
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
3559 3560 3561 3562 3563 3564 3565
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

	insert_inode_hash(inode);
	return inode;
3566
fail:
3567 3568
	if (dir)
		BTRFS_I(dir)->index_cnt--;
3569
	btrfs_free_path(path);
3570
	iput(inode);
3571
	return ERR_PTR(ret);
C
Chris Mason 已提交
3572 3573 3574 3575 3576 3577 3578
}

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

C
Chris Mason 已提交
3579 3580 3581 3582 3583 3584
/*
 * 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.
 */
3585 3586 3587
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 已提交
3588 3589 3590
{
	int ret;
	struct btrfs_key key;
3591
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
3592

C
Chris Mason 已提交
3593 3594 3595 3596
	key.objectid = inode->i_ino;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
	key.offset = 0;

3597 3598
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode->i_ino,
3599
				    &key, btrfs_inode_type(inode),
3600
				    index);
C
Chris Mason 已提交
3601
	if (ret == 0) {
3602 3603
		if (add_backref) {
			ret = btrfs_insert_inode_ref(trans, root,
3604 3605 3606 3607
						     name, name_len,
						     inode->i_ino,
						     parent_inode->i_ino,
						     index);
3608
		}
3609
		btrfs_i_size_write(parent_inode, parent_inode->i_size +
3610
				   name_len * 2);
3611
		parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
3612
		ret = btrfs_update_inode(trans, root, parent_inode);
C
Chris Mason 已提交
3613 3614 3615 3616 3617
	}
	return ret;
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
3618
			    struct dentry *dentry, struct inode *inode,
3619
			    int backref, u64 index)
C
Chris Mason 已提交
3620
{
3621 3622 3623
	int err = btrfs_add_link(trans, dentry->d_parent->d_inode,
				 inode, dentry->d_name.name,
				 dentry->d_name.len, backref, index);
C
Chris Mason 已提交
3624 3625 3626 3627 3628 3629 3630 3631 3632
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
3633 3634 3635 3636 3637
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
			int mode, dev_t rdev)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
3638
	struct inode *inode = NULL;
J
Josef Bacik 已提交
3639 3640 3641
	int err;
	int drop_inode = 0;
	u64 objectid;
3642
	unsigned long nr = 0;
3643
	u64 index = 0;
J
Josef Bacik 已提交
3644 3645 3646 3647

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

J
Josef Bacik 已提交
3648
	err = btrfs_check_metadata_free_space(root);
3649 3650 3651
	if (err)
		goto fail;

J
Josef Bacik 已提交
3652 3653 3654 3655 3656 3657 3658 3659 3660
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

3661
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3662 3663
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3664
				BTRFS_I(dir)->block_group, mode, &index);
J
Josef Bacik 已提交
3665 3666 3667 3668
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
3669
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3670 3671 3672 3673 3674
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

J
Josef Bacik 已提交
3675
	btrfs_set_trans_block_group(trans, inode);
3676
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
J
Josef Bacik 已提交
3677 3678 3679 3680 3681
	if (err)
		drop_inode = 1;
	else {
		inode->i_op = &btrfs_special_inode_operations;
		init_special_inode(inode, inode->i_mode, rdev);
3682
		btrfs_update_inode(trans, root, inode);
J
Josef Bacik 已提交
3683 3684 3685 3686 3687
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3688
	nr = trans->blocks_used;
3689
	btrfs_end_transaction_throttle(trans, root);
3690
fail:
J
Josef Bacik 已提交
3691 3692 3693 3694
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3695
	btrfs_btree_balance_dirty(root, nr);
J
Josef Bacik 已提交
3696 3697 3698
	return err;
}

C
Chris Mason 已提交
3699 3700 3701 3702 3703
static int btrfs_create(struct inode *dir, struct dentry *dentry,
			int mode, struct nameidata *nd)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
3704
	struct inode *inode = NULL;
C
Chris Mason 已提交
3705 3706
	int err;
	int drop_inode = 0;
3707
	unsigned long nr = 0;
C
Chris Mason 已提交
3708
	u64 objectid;
3709
	u64 index = 0;
C
Chris Mason 已提交
3710

J
Josef Bacik 已提交
3711
	err = btrfs_check_metadata_free_space(root);
3712 3713
	if (err)
		goto fail;
C
Chris Mason 已提交
3714 3715 3716 3717 3718 3719 3720 3721 3722
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

3723
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3724 3725
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino,
3726 3727
				objectid, BTRFS_I(dir)->block_group, mode,
				&index);
C
Chris Mason 已提交
3728 3729 3730 3731
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
3732
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3733 3734 3735 3736 3737
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
3738
	btrfs_set_trans_block_group(trans, inode);
3739
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
3740 3741 3742 3743
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
3744
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
3745 3746
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
3747
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
3748 3749 3750 3751 3752
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3753
	nr = trans->blocks_used;
3754
	btrfs_end_transaction_throttle(trans, root);
3755
fail:
C
Chris Mason 已提交
3756 3757 3758 3759
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3760
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3761 3762 3763 3764 3765 3766 3767 3768 3769
	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;
3770
	u64 index;
3771
	unsigned long nr = 0;
C
Chris Mason 已提交
3772 3773 3774 3775 3776 3777
	int err;
	int drop_inode = 0;

	if (inode->i_nlink == 0)
		return -ENOENT;

3778
	btrfs_inc_nlink(inode);
J
Josef Bacik 已提交
3779
	err = btrfs_check_metadata_free_space(root);
3780 3781
	if (err)
		goto fail;
3782
	err = btrfs_set_inode_index(dir, &index);
3783 3784 3785
	if (err)
		goto fail;

C
Chris Mason 已提交
3786
	trans = btrfs_start_transaction(root, 1);
3787

C
Chris Mason 已提交
3788 3789
	btrfs_set_trans_block_group(trans, dir);
	atomic_inc(&inode->i_count);
3790

3791
	err = btrfs_add_nondir(trans, dentry, inode, 1, index);
3792

C
Chris Mason 已提交
3793 3794
	if (err)
		drop_inode = 1;
3795

C
Chris Mason 已提交
3796 3797
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, dir);
3798
	err = btrfs_update_inode(trans, root, inode);
3799

3800 3801
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
3802

3803
	nr = trans->blocks_used;
3804 3805

	btrfs_log_new_name(trans, inode, NULL, dentry->d_parent);
3806
	btrfs_end_transaction_throttle(trans, root);
3807
fail:
C
Chris Mason 已提交
3808 3809 3810 3811
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3812
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3813 3814 3815 3816 3817
	return err;
}

static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
3818
	struct inode *inode = NULL;
C
Chris Mason 已提交
3819 3820 3821 3822
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
3823
	u64 objectid = 0;
3824
	u64 index = 0;
3825
	unsigned long nr = 1;
C
Chris Mason 已提交
3826

J
Josef Bacik 已提交
3827
	err = btrfs_check_metadata_free_space(root);
3828 3829 3830
	if (err)
		goto out_unlock;

C
Chris Mason 已提交
3831 3832
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);
3833

C
Chris Mason 已提交
3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out_unlock;
	}

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

3845
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3846 3847
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3848 3849
				BTRFS_I(dir)->block_group, S_IFDIR | mode,
				&index);
C
Chris Mason 已提交
3850 3851 3852 3853
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
3854

C
Chris Mason 已提交
3855
	drop_on_err = 1;
J
Josef Bacik 已提交
3856

J
Jim Owens 已提交
3857
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3858 3859 3860
	if (err)
		goto out_fail;

C
Chris Mason 已提交
3861 3862 3863 3864
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;
	btrfs_set_trans_block_group(trans, inode);

3865
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
3866 3867 3868
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
3869

3870 3871 3872
	err = btrfs_add_link(trans, dentry->d_parent->d_inode,
				 inode, dentry->d_name.name,
				 dentry->d_name.len, 0, index);
C
Chris Mason 已提交
3873 3874
	if (err)
		goto out_fail;
3875

C
Chris Mason 已提交
3876 3877 3878 3879 3880 3881 3882
	d_instantiate(dentry, inode);
	drop_on_err = 0;
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);

out_fail:
3883
	nr = trans->blocks_used;
3884
	btrfs_end_transaction_throttle(trans, root);
3885

C
Chris Mason 已提交
3886 3887 3888
out_unlock:
	if (drop_on_err)
		iput(inode);
3889
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3890 3891 3892
	return err;
}

C
Chris Mason 已提交
3893 3894 3895 3896
/* 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.
 */
3897 3898
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
3899 3900
				struct extent_map *em,
				u64 map_start, u64 map_len)
3901 3902 3903
{
	u64 start_diff;

3904 3905 3906 3907
	BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
	start_diff = map_start - em->start;
	em->start = map_start;
	em->len = map_len;
C
Chris Mason 已提交
3908 3909
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
3910
		em->block_start += start_diff;
C
Chris Mason 已提交
3911 3912
		em->block_len -= start_diff;
	}
3913
	return add_extent_mapping(em_tree, em);
3914 3915
}

C
Chris Mason 已提交
3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936
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;

	WARN_ON(pg_offset != 0);
	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);
	ptr = btrfs_file_extent_inline_start(item);

	read_extent_buffer(leaf, tmp, ptr, inline_size);

3937
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
C
Chris Mason 已提交
3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951
	ret = btrfs_zlib_decompress(tmp, page, extent_offset,
				    inline_size, max_size);
	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;
}

C
Chris Mason 已提交
3952 3953
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
C
Chris Mason 已提交
3954 3955
 * the ugly parts come from merging extents from the disk with the in-ram
 * representation.  This gets more complex because of the data=ordered code,
C
Chris Mason 已提交
3956 3957 3958 3959
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
C
Chris Mason 已提交
3960

3961
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3962
				    size_t pg_offset, u64 start, u64 len,
3963 3964 3965 3966
				    int create)
{
	int ret;
	int err = 0;
3967
	u64 bytenr;
3968 3969 3970 3971
	u64 extent_start = 0;
	u64 extent_end = 0;
	u64 objectid = inode->i_ino;
	u32 found_type;
3972
	struct btrfs_path *path = NULL;
3973 3974
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
3975 3976
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
3977 3978
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
3979
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3980
	struct btrfs_trans_handle *trans = NULL;
C
Chris Mason 已提交
3981
	int compressed;
3982 3983

again:
3984 3985
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
3986 3987
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
3988 3989
	spin_unlock(&em_tree->lock);

3990
	if (em) {
3991 3992 3993
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
3994 3995 3996
			free_extent_map(em);
		else
			goto out;
3997
	}
3998
	em = alloc_extent_map(GFP_NOFS);
3999
	if (!em) {
4000 4001
		err = -ENOMEM;
		goto out;
4002
	}
4003
	em->bdev = root->fs_info->fs_devices->latest_bdev;
4004
	em->start = EXTENT_MAP_HOLE;
4005
	em->orig_start = EXTENT_MAP_HOLE;
4006
	em->len = (u64)-1;
C
Chris Mason 已提交
4007
	em->block_len = (u64)-1;
4008 4009 4010 4011 4012 4013

	if (!path) {
		path = btrfs_alloc_path();
		BUG_ON(!path);
	}

4014 4015
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

4027 4028
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
4029 4030
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
4031 4032 4033
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
4034 4035 4036 4037
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

4038 4039
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
C
Chris Mason 已提交
4040
	compressed = btrfs_file_extent_compression(leaf, item);
Y
Yan Zheng 已提交
4041 4042
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
4043
		extent_end = extent_start +
4044
		       btrfs_file_extent_num_bytes(leaf, item);
Y
Yan Zheng 已提交
4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
	} 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;
4059
			}
Y
Yan Zheng 已提交
4060 4061 4062
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
4063
		}
Y
Yan Zheng 已提交
4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074
		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;
	}

Y
Yan Zheng 已提交
4075 4076
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
4077 4078
		em->start = extent_start;
		em->len = extent_end - extent_start;
4079 4080
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
4081 4082
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
4083
			em->block_start = EXTENT_MAP_HOLE;
4084 4085
			goto insert;
		}
C
Chris Mason 已提交
4086 4087 4088 4089 4090 4091 4092 4093 4094
		if (compressed) {
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
			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;
Y
Yan Zheng 已提交
4095 4096
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
C
Chris Mason 已提交
4097
		}
4098 4099
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
4100
		unsigned long ptr;
4101
		char *map;
4102 4103 4104
		size_t size;
		size_t extent_offset;
		size_t copy_size;
4105

4106
		em->block_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4107
		if (!page || create) {
4108
			em->start = extent_start;
Y
Yan Zheng 已提交
4109
			em->len = extent_end - extent_start;
4110 4111
			goto out;
		}
4112

Y
Yan Zheng 已提交
4113 4114
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
4115
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
4116 4117
				size - extent_offset);
		em->start = extent_start + extent_offset;
4118 4119
		em->len = (copy_size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
4120
		em->orig_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4121 4122
		if (compressed)
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
4123
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
4124
		if (create == 0 && !PageUptodate(page)) {
C
Chris Mason 已提交
4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136
			if (btrfs_file_extent_compression(leaf, item) ==
			    BTRFS_COMPRESS_ZLIB) {
				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);
				kunmap(page);
			}
4137 4138 4139 4140 4141 4142 4143
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
				btrfs_release_path(root, path);
4144
				trans = btrfs_join_transaction(root, 1);
4145 4146
				goto again;
			}
C
Chris Mason 已提交
4147
			map = kmap(page);
4148
			write_extent_buffer(leaf, map + pg_offset, ptr,
4149
					    copy_size);
C
Chris Mason 已提交
4150
			kunmap(page);
4151
			btrfs_mark_buffer_dirty(leaf);
4152
		}
4153 4154
		set_extent_uptodate(io_tree, em->start,
				    extent_map_end(em) - 1, GFP_NOFS);
4155 4156
		goto insert;
	} else {
C
Chris Mason 已提交
4157
		printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
4158 4159 4160 4161
		WARN_ON(1);
	}
not_found:
	em->start = start;
4162
	em->len = len;
4163
not_found_em:
4164
	em->block_start = EXTENT_MAP_HOLE;
Y
Yan Zheng 已提交
4165
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
4166 4167
insert:
	btrfs_release_path(root, path);
4168
	if (em->start > start || extent_map_end(em) <= start) {
C
Chris Mason 已提交
4169 4170 4171 4172 4173
		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);
4174 4175 4176
		err = -EIO;
		goto out;
	}
4177 4178 4179

	err = 0;
	spin_lock(&em_tree->lock);
4180
	ret = add_extent_mapping(em_tree, em);
4181 4182 4183 4184
	/* 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
	 */
4185
	if (ret == -EEXIST) {
4186
		struct extent_map *existing;
4187 4188 4189

		ret = 0;

4190
		existing = lookup_extent_mapping(em_tree, start, len);
4191 4192 4193 4194 4195
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
4196 4197 4198 4199 4200
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
4201 4202
							   em, start,
							   root->sectorsize);
4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
				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;
4216
			err = 0;
4217 4218
		}
	}
4219
	spin_unlock(&em_tree->lock);
4220
out:
4221 4222
	if (path)
		btrfs_free_path(path);
4223 4224
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
4225
		if (!err)
4226 4227 4228 4229 4230 4231 4232 4233 4234 4235
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		WARN_ON(1);
		return ERR_PTR(err);
	}
	return em;
}

4236 4237 4238 4239
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
4240
	return -EINVAL;
4241 4242
}

Y
Yehuda Sadeh 已提交
4243 4244 4245 4246 4247 4248
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent);
}

4249
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
4250
{
4251 4252
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4253
	return extent_read_full_page(tree, page, btrfs_get_extent);
C
Chris Mason 已提交
4254
}
4255

4256
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
4257
{
4258
	struct extent_io_tree *tree;
4259 4260 4261 4262 4263 4264 4265


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

4270 4271
int btrfs_writepages(struct address_space *mapping,
		     struct writeback_control *wbc)
C
Chris Mason 已提交
4272
{
4273
	struct extent_io_tree *tree;
4274

4275
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4276 4277 4278
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
4279 4280 4281 4282
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
4283 4284
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4285 4286 4287
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
4288
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
C
Chris Mason 已提交
4289
{
4290 4291
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
4292
	int ret;
4293

4294 4295
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
4296
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
4297 4298 4299 4300
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
4301
	}
4302
	return ret;
C
Chris Mason 已提交
4303 4304
}

4305 4306
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
4307 4308
	if (PageWriteback(page) || PageDirty(page))
		return 0;
4309
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
4310 4311
}

4312
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
4313
{
4314
	struct extent_io_tree *tree;
4315 4316 4317
	struct btrfs_ordered_extent *ordered;
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
4318

4319
	wait_on_page_writeback(page);
4320
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4321 4322 4323 4324 4325 4326 4327 4328 4329
	if (offset) {
		btrfs_releasepage(page, GFP_NOFS);
		return;
	}

	lock_extent(tree, page_start, page_end, GFP_NOFS);
	ordered = btrfs_lookup_ordered_extent(page->mapping->host,
					   page_offset(page));
	if (ordered) {
4330 4331 4332 4333
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
4334 4335 4336
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
				 EXTENT_LOCKED, 1, 0, GFP_NOFS);
4337 4338
		btrfs_finish_ordered_io(page->mapping->host,
					page_start, page_end);
4339 4340 4341 4342 4343 4344 4345 4346 4347
		btrfs_put_ordered_extent(ordered);
		lock_extent(tree, page_start, page_end, GFP_NOFS);
	}
	clear_extent_bit(tree, page_start, page_end,
		 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
		 EXTENT_ORDERED,
		 1, 1, GFP_NOFS);
	__btrfs_releasepage(page, GFP_NOFS);

C
Chris Mason 已提交
4348
	ClearPageChecked(page);
4349 4350 4351 4352 4353
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
4354 4355
}

C
Chris Mason 已提交
4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370
/*
 * 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.
 */
4371
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
C
Chris Mason 已提交
4372
{
4373
	struct page *page = vmf->page;
4374
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
4375
	struct btrfs_root *root = BTRFS_I(inode)->root;
4376 4377 4378 4379
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
	char *kaddr;
	unsigned long zero_start;
C
Chris Mason 已提交
4380
	loff_t size;
4381
	int ret;
4382
	u64 page_start;
4383
	u64 page_end;
C
Chris Mason 已提交
4384

J
Josef Bacik 已提交
4385
	ret = btrfs_check_data_free_space(root, inode, PAGE_CACHE_SIZE);
4386 4387 4388 4389 4390
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
4391
		goto out;
4392
	}
4393

4394
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
4395
again:
C
Chris Mason 已提交
4396 4397
	lock_page(page);
	size = i_size_read(inode);
4398 4399
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
4400

C
Chris Mason 已提交
4401
	if ((page->mapping != inode->i_mapping) ||
4402
	    (page_start >= size)) {
J
Josef Bacik 已提交
4403
		btrfs_free_reserved_data_space(root, inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
4404 4405 4406
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
4407 4408 4409 4410 4411
	wait_on_page_writeback(page);

	lock_extent(io_tree, page_start, page_end, GFP_NOFS);
	set_page_extent_mapped(page);

4412 4413 4414 4415
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
4416 4417 4418 4419
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
		unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
		unlock_page(page);
4420
		btrfs_start_ordered_extent(inode, ordered, 1);
4421 4422 4423 4424
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

4425
	btrfs_set_extent_delalloc(inode, page_start, page_end);
4426
	ret = 0;
C
Chris Mason 已提交
4427 4428

	/* page is wholly or partially inside EOF */
4429
	if (page_start + PAGE_CACHE_SIZE > size)
4430
		zero_start = size & ~PAGE_CACHE_MASK;
C
Chris Mason 已提交
4431
	else
4432
		zero_start = PAGE_CACHE_SIZE;
C
Chris Mason 已提交
4433

4434 4435 4436 4437 4438 4439
	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);
	}
4440
	ClearPageChecked(page);
4441
	set_page_dirty(page);
4442 4443

	BTRFS_I(inode)->last_trans = root->fs_info->generation + 1;
4444
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
4445 4446 4447

out_unlock:
	unlock_page(page);
4448
out:
C
Chris Mason 已提交
4449 4450 4451
	return ret;
}

C
Chris Mason 已提交
4452 4453 4454 4455 4456
static void btrfs_truncate(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;
	struct btrfs_trans_handle *trans;
4457
	unsigned long nr;
4458
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
4459 4460 4461 4462 4463 4464 4465

	if (!S_ISREG(inode->i_mode))
		return;
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return;

	btrfs_truncate_page(inode->i_mapping, inode->i_size);
C
Chris Mason 已提交
4466
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
C
Chris Mason 已提交
4467 4468

	trans = btrfs_start_transaction(root, 1);
4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489

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

C
Chris Mason 已提交
4490
	btrfs_set_trans_block_group(trans, inode);
4491
	btrfs_i_size_write(inode, inode->i_size);
C
Chris Mason 已提交
4492

4493 4494 4495
	ret = btrfs_orphan_add(trans, inode);
	if (ret)
		goto out;
C
Chris Mason 已提交
4496
	/* FIXME, add redo link to tree so we don't leak on crash */
4497
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size,
4498
				      BTRFS_EXTENT_DATA_KEY);
C
Chris Mason 已提交
4499
	btrfs_update_inode(trans, root, inode);
4500

4501 4502 4503 4504 4505
	ret = btrfs_orphan_del(trans, inode);
	BUG_ON(ret);

out:
	nr = trans->blocks_used;
4506
	ret = btrfs_end_transaction_throttle(trans, root);
C
Chris Mason 已提交
4507
	BUG_ON(ret);
4508
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4509 4510
}

C
Chris Mason 已提交
4511 4512 4513
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
4514 4515 4516
int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
			     struct btrfs_root *new_root, struct dentry *dentry,
			     u64 new_dirid, u64 alloc_hint)
C
Chris Mason 已提交
4517 4518
{
	struct inode *inode;
4519
	int error;
4520
	u64 index = 0;
C
Chris Mason 已提交
4521

4522
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid,
4523
				new_dirid, alloc_hint, S_IFDIR | 0700, &index);
4524
	if (IS_ERR(inode))
C
Christoph Hellwig 已提交
4525
		return PTR_ERR(inode);
C
Chris Mason 已提交
4526 4527 4528 4529
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

	inode->i_nlink = 1;
4530
	btrfs_i_size_write(inode, 0);
4531

4532 4533 4534 4535 4536 4537
	error = btrfs_update_inode(trans, new_root, inode);
	if (error)
		return error;

	d_instantiate(dentry, inode);
	return 0;
C
Chris Mason 已提交
4538 4539
}

C
Chris Mason 已提交
4540 4541 4542
/* helper function for file defrag and space balancing.  This
 * forces readahead on a given range of bytes in an inode
 */
4543
unsigned long btrfs_force_ra(struct address_space *mapping,
4544 4545 4546
			      struct file_ra_state *ra, struct file *file,
			      pgoff_t offset, pgoff_t last_index)
{
4547
	pgoff_t req_size = last_index - offset + 1;
4548 4549 4550 4551 4552

	page_cache_sync_readahead(mapping, ra, file, offset, req_size);
	return offset + req_size;
}

C
Chris Mason 已提交
4553 4554 4555 4556 4557 4558 4559
struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
4560
	ei->last_trans = 0;
4561
	ei->logged_trans = 0;
4562
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
J
Josef Bacik 已提交
4563 4564
	ei->i_acl = BTRFS_ACL_NOT_CACHED;
	ei->i_default_acl = BTRFS_ACL_NOT_CACHED;
4565
	INIT_LIST_HEAD(&ei->i_orphan);
4566
	INIT_LIST_HEAD(&ei->ordered_operations);
C
Chris Mason 已提交
4567 4568 4569 4570 4571
	return &ei->vfs_inode;
}

void btrfs_destroy_inode(struct inode *inode)
{
4572
	struct btrfs_ordered_extent *ordered;
4573 4574
	struct btrfs_root *root = BTRFS_I(inode)->root;

C
Chris Mason 已提交
4575 4576 4577
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);

J
Josef Bacik 已提交
4578 4579 4580 4581 4582 4583 4584
	if (BTRFS_I(inode)->i_acl &&
	    BTRFS_I(inode)->i_acl != BTRFS_ACL_NOT_CACHED)
		posix_acl_release(BTRFS_I(inode)->i_acl);
	if (BTRFS_I(inode)->i_default_acl &&
	    BTRFS_I(inode)->i_default_acl != BTRFS_ACL_NOT_CACHED)
		posix_acl_release(BTRFS_I(inode)->i_default_acl);

4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596
	/*
	 * 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);
	}

	spin_lock(&root->list_lock);
4597 4598 4599 4600 4601
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
		printk(KERN_ERR "BTRFS: inode %lu: inode still on the orphan"
		       " list\n", inode->i_ino);
		dump_stack();
	}
4602
	spin_unlock(&root->list_lock);
4603

C
Chris Mason 已提交
4604
	while (1) {
4605 4606 4607 4608
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
C
Chris Mason 已提交
4609 4610 4611 4612
			printk(KERN_ERR "btrfs found ordered "
			       "extent %llu %llu on inode cleanup\n",
			       (unsigned long long)ordered->file_offset,
			       (unsigned long long)ordered->len);
4613 4614 4615 4616 4617
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
4618
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
C
Chris Mason 已提交
4619 4620 4621
	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

4622
static void init_once(void *foo)
C
Chris Mason 已提交
4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644
{
	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_bit_radix_cachep)
		kmem_cache_destroy(btrfs_bit_radix_cachep);
	if (btrfs_path_cachep)
		kmem_cache_destroy(btrfs_path_cachep);
}

int btrfs_init_cachep(void)
{
4645 4646 4647
	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 已提交
4648 4649
	if (!btrfs_inode_cachep)
		goto fail;
4650 4651 4652 4653

	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 已提交
4654 4655
	if (!btrfs_trans_handle_cachep)
		goto fail;
4656 4657 4658 4659

	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
4660 4661
	if (!btrfs_transaction_cachep)
		goto fail;
4662 4663 4664 4665

	btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
			sizeof(struct btrfs_path), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
4666 4667
	if (!btrfs_path_cachep)
		goto fail;
4668 4669 4670 4671

	btrfs_bit_radix_cachep = kmem_cache_create("btrfs_radix", 256, 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
			SLAB_DESTROY_BY_RCU, NULL);
C
Chris Mason 已提交
4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
	if (!btrfs_bit_radix_cachep)
		goto fail;
	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;
	generic_fillattr(inode, stat);
4685
	stat->dev = BTRFS_I(inode)->root->anon_super.s_dev;
C
Chris Mason 已提交
4686
	stat->blksize = PAGE_CACHE_SIZE;
4687 4688
	stat->blocks = (inode_get_bytes(inode) +
			BTRFS_I(inode)->delalloc_bytes) >> 9;
C
Chris Mason 已提交
4689 4690 4691
	return 0;
}

C
Chris Mason 已提交
4692 4693
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
4694 4695 4696 4697 4698 4699
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
4700
	u64 index = 0;
C
Chris Mason 已提交
4701 4702
	int ret;

4703 4704 4705 4706 4707
	/* we're not allowed to rename between subvolumes */
	if (BTRFS_I(old_inode)->root->root_key.objectid !=
	    BTRFS_I(new_dir)->root->root_key.objectid)
		return -EXDEV;

C
Chris Mason 已提交
4708 4709 4710 4711
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
		return -ENOTEMPTY;
	}
4712

4713 4714 4715 4716 4717 4718
	/* to rename a snapshot or subvolume, we need to juggle the
	 * backrefs.  This isn't coded yet
	 */
	if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
		return -EXDEV;

J
Josef Bacik 已提交
4719
	ret = btrfs_check_metadata_free_space(root);
4720 4721 4722
	if (ret)
		goto out_unlock;

4723 4724 4725 4726 4727 4728 4729 4730 4731 4732
	/*
	 * 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
	 */
	if (new_inode && old_inode && S_ISREG(old_inode->i_mode) &&
	    new_inode->i_size &&
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

C
Chris Mason 已提交
4733
	trans = btrfs_start_transaction(root, 1);
4734

4735 4736 4737 4738 4739 4740 4741 4742 4743
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
	if (new_inode && new_inode->i_size &&
	    old_inode && S_ISREG(old_inode->i_mode)) {
		btrfs_add_ordered_operation(trans, root, old_inode);
	}

4744 4745 4746 4747 4748 4749 4750 4751 4752
	/*
	 * 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);

C
Chris Mason 已提交
4753 4754
	btrfs_set_trans_block_group(trans, new_dir);

4755
	btrfs_inc_nlink(old_dentry->d_inode);
C
Chris Mason 已提交
4756 4757 4758
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
4759

4760 4761 4762
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

4763 4764 4765
	ret = btrfs_unlink_inode(trans, root, old_dir, old_dentry->d_inode,
				 old_dentry->d_name.name,
				 old_dentry->d_name.len);
C
Chris Mason 已提交
4766 4767 4768 4769 4770
	if (ret)
		goto out_fail;

	if (new_inode) {
		new_inode->i_ctime = CURRENT_TIME;
4771 4772 4773 4774
		ret = btrfs_unlink_inode(trans, root, new_dir,
					 new_dentry->d_inode,
					 new_dentry->d_name.name,
					 new_dentry->d_name.len);
C
Chris Mason 已提交
4775 4776
		if (ret)
			goto out_fail;
4777
		if (new_inode->i_nlink == 0) {
4778
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
4779 4780 4781
			if (ret)
				goto out_fail;
		}
4782

C
Chris Mason 已提交
4783
	}
4784
	ret = btrfs_set_inode_index(new_dir, &index);
4785 4786 4787
	if (ret)
		goto out_fail;

4788 4789 4790
	ret = btrfs_add_link(trans, new_dentry->d_parent->d_inode,
			     old_inode, new_dentry->d_name.name,
			     new_dentry->d_name.len, 1, index);
C
Chris Mason 已提交
4791 4792 4793
	if (ret)
		goto out_fail;

4794 4795
	btrfs_log_new_name(trans, old_inode, old_dir,
				       new_dentry->d_parent);
C
Chris Mason 已提交
4796
out_fail:
4797 4798 4799 4800 4801

	/* this btrfs_end_log_trans just allows the current
	 * log-sub transaction to complete
	 */
	btrfs_end_log_trans(root);
4802
	btrfs_end_transaction_throttle(trans, root);
4803
out_unlock:
C
Chris Mason 已提交
4804 4805 4806
	return ret;
}

C
Chris Mason 已提交
4807 4808 4809 4810
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
4811 4812 4813 4814
int btrfs_start_delalloc_inodes(struct btrfs_root *root)
{
	struct list_head *head = &root->fs_info->delalloc_inodes;
	struct btrfs_inode *binode;
4815
	struct inode *inode;
4816

Y
Yan Zheng 已提交
4817 4818 4819
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

4820
	spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
4821
	while (!list_empty(head)) {
4822 4823
		binode = list_entry(head->next, struct btrfs_inode,
				    delalloc_inodes);
4824 4825 4826
		inode = igrab(&binode->vfs_inode);
		if (!inode)
			list_del_init(&binode->delalloc_inodes);
4827
		spin_unlock(&root->fs_info->delalloc_lock);
4828
		if (inode) {
4829
			filemap_flush(inode->i_mapping);
4830 4831 4832
			iput(inode);
		}
		cond_resched();
4833
		spin_lock(&root->fs_info->delalloc_lock);
4834
	}
4835
	spin_unlock(&root->fs_info->delalloc_lock);
4836 4837 4838 4839 4840 4841

	/* 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);
C
Chris Mason 已提交
4842
	while (atomic_read(&root->fs_info->nr_async_submits) ||
4843
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
4844
		wait_event(root->fs_info->async_submit_wait,
4845 4846
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
4847 4848
	}
	atomic_dec(&root->fs_info->async_submit_draining);
4849 4850 4851
	return 0;
}

C
Chris Mason 已提交
4852 4853 4854 4855 4856 4857 4858
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;
4859
	struct inode *inode = NULL;
C
Chris Mason 已提交
4860 4861 4862
	int err;
	int drop_inode = 0;
	u64 objectid;
4863
	u64 index = 0 ;
C
Chris Mason 已提交
4864 4865
	int name_len;
	int datasize;
4866
	unsigned long ptr;
C
Chris Mason 已提交
4867
	struct btrfs_file_extent_item *ei;
4868
	struct extent_buffer *leaf;
4869
	unsigned long nr = 0;
C
Chris Mason 已提交
4870 4871 4872 4873

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

J
Josef Bacik 已提交
4875
	err = btrfs_check_metadata_free_space(root);
4876 4877 4878
	if (err)
		goto out_fail;

C
Chris Mason 已提交
4879 4880 4881 4882 4883 4884 4885 4886 4887
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

4888
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4889 4890
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
4891 4892
				BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
				&index);
C
Chris Mason 已提交
4893 4894 4895 4896
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
4897
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
4898 4899 4900 4901 4902
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
4903
	btrfs_set_trans_block_group(trans, inode);
4904
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
4905 4906 4907 4908
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
4909
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
4910 4911
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
4912
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	key.objectid = inode->i_ino;
	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);
4928 4929 4930 4931
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}
4932 4933 4934 4935 4936
	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 已提交
4937
				   BTRFS_FILE_EXTENT_INLINE);
C
Chris Mason 已提交
4938 4939 4940 4941 4942
	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 已提交
4943
	ptr = btrfs_file_extent_inline_start(ei);
4944 4945
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
4946
	btrfs_free_path(path);
4947

C
Chris Mason 已提交
4948 4949
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
4950
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
Y
Yan Zheng 已提交
4951
	inode_set_bytes(inode, name_len);
4952
	btrfs_i_size_write(inode, name_len - 1);
4953 4954 4955
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
4956 4957

out_unlock:
4958
	nr = trans->blocks_used;
4959
	btrfs_end_transaction_throttle(trans, root);
4960
out_fail:
C
Chris Mason 已提交
4961 4962 4963 4964
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
4965
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4966 4967
	return err;
}
4968

4969 4970
static int prealloc_file_range(struct btrfs_trans_handle *trans,
			       struct inode *inode, u64 start, u64 end,
Y
Yan Zheng 已提交
4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022
			       u64 alloc_hint, int mode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 alloc_size;
	u64 cur_offset = start;
	u64 num_bytes = end - start;
	int ret = 0;

	while (num_bytes > 0) {
		alloc_size = min(num_bytes, root->fs_info->max_extent);
		ret = btrfs_reserve_extent(trans, root, alloc_size,
					   root->sectorsize, 0, alloc_hint,
					   (u64)-1, &ins, 1);
		if (ret) {
			WARN_ON(1);
			goto out;
		}
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
						  ins.offset, 0, 0, 0,
						  BTRFS_FILE_EXTENT_PREALLOC);
		BUG_ON(ret);
		num_bytes -= ins.offset;
		cur_offset += ins.offset;
		alloc_hint = ins.objectid + ins.offset;
	}
out:
	if (cur_offset > start) {
		inode->i_ctime = CURRENT_TIME;
		btrfs_set_flag(inode, PREALLOC);
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
		    cur_offset > i_size_read(inode))
			btrfs_i_size_write(inode, cur_offset);
		ret = btrfs_update_inode(trans, root, inode);
		BUG_ON(ret);
	}

	return ret;
}

static long btrfs_fallocate(struct inode *inode, int mode,
			    loff_t offset, loff_t len)
{
	u64 cur_offset;
	u64 last_byte;
	u64 alloc_start;
	u64 alloc_end;
	u64 alloc_hint = 0;
	u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
	struct extent_map *em;
5023
	struct btrfs_trans_handle *trans;
Y
Yan Zheng 已提交
5024 5025 5026 5027 5028
	int ret;

	alloc_start = offset & ~mask;
	alloc_end =  (offset + len + mask) & ~mask;

5029 5030 5031 5032 5033 5034
	/*
	 * wait for ordered IO before we have any locks.  We'll loop again
	 * below with the locks held.
	 */
	btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);

Y
Yan Zheng 已提交
5035 5036 5037 5038 5039 5040 5041 5042 5043
	mutex_lock(&inode->i_mutex);
	if (alloc_start > inode->i_size) {
		ret = btrfs_cont_expand(inode, alloc_start);
		if (ret)
			goto out;
	}

	while (1) {
		struct btrfs_ordered_extent *ordered;
5044 5045 5046 5047 5048 5049 5050 5051 5052 5053

		trans = btrfs_start_transaction(BTRFS_I(inode)->root, 1);
		if (!trans) {
			ret = -EIO;
			goto out;
		}

		/* the extent lock is ordered inside the running
		 * transaction
		 */
Y
Yan Zheng 已提交
5054 5055 5056 5057 5058 5059 5060 5061 5062 5063
		lock_extent(&BTRFS_I(inode)->io_tree, alloc_start,
			    alloc_end - 1, GFP_NOFS);
		ordered = btrfs_lookup_first_ordered_extent(inode,
							    alloc_end - 1);
		if (ordered &&
		    ordered->file_offset + ordered->len > alloc_start &&
		    ordered->file_offset < alloc_end) {
			btrfs_put_ordered_extent(ordered);
			unlock_extent(&BTRFS_I(inode)->io_tree,
				      alloc_start, alloc_end - 1, GFP_NOFS);
5064 5065 5066 5067 5068 5069
			btrfs_end_transaction(trans, BTRFS_I(inode)->root);

			/*
			 * we can't wait on the range with the transaction
			 * running or with the extent lock held
			 */
Y
Yan Zheng 已提交
5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086
			btrfs_wait_ordered_range(inode, alloc_start,
						 alloc_end - alloc_start);
		} else {
			if (ordered)
				btrfs_put_ordered_extent(ordered);
			break;
		}
	}

	cur_offset = alloc_start;
	while (1) {
		em = btrfs_get_extent(inode, NULL, 0, cur_offset,
				      alloc_end - cur_offset, 0);
		BUG_ON(IS_ERR(em) || !em);
		last_byte = min(extent_map_end(em), alloc_end);
		last_byte = (last_byte + mask) & ~mask;
		if (em->block_start == EXTENT_MAP_HOLE) {
5087
			ret = prealloc_file_range(trans, inode, cur_offset,
Y
Yan Zheng 已提交
5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105
					last_byte, alloc_hint, mode);
			if (ret < 0) {
				free_extent_map(em);
				break;
			}
		}
		if (em->block_start <= EXTENT_MAP_LAST_BYTE)
			alloc_hint = em->block_start;
		free_extent_map(em);

		cur_offset = last_byte;
		if (cur_offset >= alloc_end) {
			ret = 0;
			break;
		}
	}
	unlock_extent(&BTRFS_I(inode)->io_tree, alloc_start, alloc_end - 1,
		      GFP_NOFS);
5106 5107

	btrfs_end_transaction(trans, BTRFS_I(inode)->root);
Y
Yan Zheng 已提交
5108 5109 5110 5111 5112
out:
	mutex_unlock(&inode->i_mutex);
	return ret;
}

5113 5114 5115 5116 5117
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

5118
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
5119 5120 5121
{
	if (btrfs_test_flag(inode, READONLY) && (mask & MAY_WRITE))
		return -EACCES;
J
Josef Bacik 已提交
5122
	return generic_permission(inode, mask, btrfs_check_acl);
Y
Yan 已提交
5123
}
C
Chris Mason 已提交
5124 5125

static struct inode_operations btrfs_dir_inode_operations = {
5126
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
5127 5128 5129 5130 5131 5132 5133 5134 5135
	.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 已提交
5136
	.mknod		= btrfs_mknod,
5137 5138
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5139
	.listxattr	= btrfs_listxattr,
5140
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
5141
	.permission	= btrfs_permission,
C
Chris Mason 已提交
5142 5143 5144
};
static struct inode_operations btrfs_dir_ro_inode_operations = {
	.lookup		= btrfs_lookup,
Y
Yan 已提交
5145
	.permission	= btrfs_permission,
C
Chris Mason 已提交
5146 5147 5148 5149
};
static struct file_operations btrfs_dir_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
5150
	.readdir	= btrfs_real_readdir,
C
Christoph Hellwig 已提交
5151
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
5152
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
5153
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
5154
#endif
S
Sage Weil 已提交
5155
	.release        = btrfs_release_file,
5156
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
5157 5158
};

5159
static struct extent_io_ops btrfs_extent_io_ops = {
5160
	.fill_delalloc = run_delalloc_range,
5161
	.submit_bio_hook = btrfs_submit_bio_hook,
5162
	.merge_bio_hook = btrfs_merge_bio_hook,
5163
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
5164
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
5165
	.writepage_start_hook = btrfs_writepage_start_hook,
5166
	.readpage_io_failed_hook = btrfs_io_failed_hook,
C
Chris Mason 已提交
5167 5168
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
5169 5170
};

5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182
/*
 * 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.
 */
C
Chris Mason 已提交
5183 5184 5185
static struct address_space_operations btrfs_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
5186
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
5187
	.readpages	= btrfs_readpages,
C
Chris Mason 已提交
5188
	.sync_page	= block_sync_page,
5189
	.direct_IO	= btrfs_direct_IO,
5190 5191
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
5192
	.set_page_dirty	= btrfs_set_page_dirty,
C
Chris Mason 已提交
5193 5194 5195 5196 5197
};

static struct address_space_operations btrfs_symlink_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
5198 5199
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
5200 5201 5202 5203 5204 5205
};

static struct inode_operations btrfs_file_inode_operations = {
	.truncate	= btrfs_truncate,
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
5206 5207
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5208
	.listxattr      = btrfs_listxattr,
5209
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
5210
	.permission	= btrfs_permission,
Y
Yan Zheng 已提交
5211
	.fallocate	= btrfs_fallocate,
Y
Yehuda Sadeh 已提交
5212
	.fiemap		= btrfs_fiemap,
C
Chris Mason 已提交
5213
};
J
Josef Bacik 已提交
5214 5215 5216
static struct inode_operations btrfs_special_inode_operations = {
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
5217
	.permission	= btrfs_permission,
5218 5219
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5220
	.listxattr	= btrfs_listxattr,
5221
	.removexattr	= btrfs_removexattr,
J
Josef Bacik 已提交
5222
};
C
Chris Mason 已提交
5223 5224 5225 5226
static struct inode_operations btrfs_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
Y
Yan 已提交
5227
	.permission	= btrfs_permission,
J
Jim Owens 已提交
5228 5229 5230 5231
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
C
Chris Mason 已提交
5232
};