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

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

C
Chris Mason 已提交
94 95 96 97
/*
 * a very lame attempt at stopping writes when the FS is 85% full.  There
 * are countless ways this is incorrect, but it is better than nothing.
 */
98 99 100
int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
			   int for_del)
{
101 102
	u64 total;
	u64 used;
103 104 105
	u64 thresh;
	int ret = 0;

106
	spin_lock(&root->fs_info->delalloc_lock);
107 108
	total = btrfs_super_total_bytes(&root->fs_info->super_copy);
	used = btrfs_super_bytes_used(&root->fs_info->super_copy);
109
	if (for_del)
110
		thresh = total * 90;
111
	else
112 113 114
		thresh = total * 85;

	do_div(thresh, 100);
115 116 117

	if (used + root->fs_info->delalloc_bytes + num_required > thresh)
		ret = -ENOSPC;
118
	spin_unlock(&root->fs_info->delalloc_lock);
119 120 121
	return ret;
}

C
Chris Mason 已提交
122 123 124 125 126
/*
 * this does all the hard work for inserting an inline extent into
 * the btree.  The caller should have done a btrfs_drop_extents so that
 * no overlapping inline items exist in the btree
 */
C
Chris Mason 已提交
127
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
				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 已提交
151 152
	path = btrfs_alloc_path();
	if (!path)
C
Chris Mason 已提交
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
		return -ENOMEM;

	btrfs_set_trans_block_group(trans, inode);

	key.objectid = inode->i_ino;
	key.offset = start;
	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
	inode_add_bytes(inode, size);
	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 已提交
184
		while (compressed_size > 0) {
C
Chris Mason 已提交
185
			cpage = compressed_pages[i];
186
			cur_size = min_t(unsigned long, compressed_size,
C
Chris Mason 已提交
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
				       PAGE_CACHE_SIZE);

			kaddr = kmap(cpage);
			write_extent_buffer(leaf, kaddr, ptr, cur_size);
			kunmap(cpage);

			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.
 */
static int cow_file_range_inline(struct btrfs_trans_handle *trans,
				 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 已提交
245
	    actual_end >= PAGE_CACHE_SIZE ||
C
Chris Mason 已提交
246 247 248 249 250 251 252 253 254
	    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 已提交
255
				 aligned_end, start, &hint_byte);
C
Chris Mason 已提交
256 257 258 259 260 261 262 263 264 265 266 267
	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;
}

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
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 已提交
305
/*
306 307 308
 * 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 已提交
309
 *
310 311 312 313 314
 * 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 已提交
315
 *
316 317 318 319
 * 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 已提交
320
 */
321 322 323 324 325
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)
326 327 328
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
329
	u64 num_bytes;
C
Chris Mason 已提交
330 331
	u64 orig_start;
	u64 disk_num_bytes;
332
	u64 blocksize = root->sectorsize;
C
Chris Mason 已提交
333
	u64 actual_end;
334
	u64 isize = i_size_read(inode);
335
	int ret = 0;
C
Chris Mason 已提交
336 337 338 339 340 341
	struct page **pages = NULL;
	unsigned long nr_pages;
	unsigned long nr_pages_ret = 0;
	unsigned long total_compressed = 0;
	unsigned long total_in = 0;
	unsigned long max_compressed = 128 * 1024;
342
	unsigned long max_uncompressed = 128 * 1024;
C
Chris Mason 已提交
343 344
	int i;
	int will_compress;
345

C
Chris Mason 已提交
346 347
	orig_start = start;

348
	actual_end = min_t(u64, isize, end + 1);
C
Chris Mason 已提交
349 350 351 352
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);
353

C
Chris Mason 已提交
354 355 356 357
	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
358 359 360 361 362 363 364
	 * 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 已提交
365 366
	 */
	total_compressed = min(total_compressed, max_uncompressed);
367
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
368
	num_bytes = max(blocksize,  num_bytes);
C
Chris Mason 已提交
369 370 371
	disk_num_bytes = num_bytes;
	total_in = 0;
	ret = 0;
372

373 374 375 376
	/*
	 * 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 已提交
377 378 379 380
	 */
	if (!btrfs_test_flag(inode, NOCOMPRESS) &&
	    btrfs_test_opt(root, COMPRESS)) {
		WARN_ON(pages);
381
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
C
Chris Mason 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408

		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) {
409 410 411 412
		trans = btrfs_join_transaction(root, 1);
		BUG_ON(!trans);
		btrfs_set_trans_block_group(trans, inode);

C
Chris Mason 已提交
413
		/* lets try to make an inline extent */
414
		if (ret || total_in < (actual_end - start)) {
C
Chris Mason 已提交
415
			/* we didn't compress the entire range, try
416
			 * to make an uncompressed inline extent.
C
Chris Mason 已提交
417 418 419 420
			 */
			ret = cow_file_range_inline(trans, root, inode,
						    start, end, 0, NULL);
		} else {
421
			/* try making a compressed inline extent */
C
Chris Mason 已提交
422 423 424 425
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
						    total_compressed, pages);
		}
426
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
427
		if (ret == 0) {
428 429 430 431 432
			/*
			 * 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 已提交
433 434
			extent_clear_unlock_delalloc(inode,
						     &BTRFS_I(inode)->io_tree,
435 436
						     start, end, NULL, 1, 0,
						     0, 1, 1, 1);
C
Chris Mason 已提交
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 465 466 467 468 469
			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 已提交
470
			WARN_ON(pages[i]->mapping);
C
Chris Mason 已提交
471 472 473 474 475 476 477 478 479 480
			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);
	}
481 482
	if (will_compress) {
		*num_added += 1;
C
Chris Mason 已提交
483

484 485 486 487 488 489
		/* 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);
490

491
		if (start + num_bytes < end && start + num_bytes < actual_end) {
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
			start += num_bytes;
			pages = NULL;
			cond_resched();
			goto again;
		}
	} else {
		/*
		 * 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;
	}
513

514 515 516 517 518 519 520 521
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 已提交
522
	kfree(pages);
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550

	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 已提交
551
	while (!list_empty(&async_cow->extents)) {
552 553 554
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
C
Chris Mason 已提交
555

556 557 558 559 560 561 562 563
		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 已提交
564 565
				    async_extent->start +
				    async_extent->ram_size - 1, GFP_NOFS);
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582

			/* 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 已提交
583
						  async_extent->start +
584 585 586 587 588 589 590 591 592 593 594
						  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 已提交
595
		/*
596 597
		 * here we're doing allocation and writeback of the
		 * compressed pages
C
Chris Mason 已提交
598
		 */
599 600 601 602 603 604 605 606 607 608 609 610 611
		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;
612
		em->orig_start = em->start;
C
Chris Mason 已提交
613

614 615 616 617 618 619
		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 已提交
620
		while (1) {
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 649 650 651 652
			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 已提交
653 654 655 656 657
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
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 694 695 696 697

		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;
698
	u64 isize = i_size_read(inode);
699 700 701 702 703 704 705 706 707
	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);

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

	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 已提交
737
	while (disk_num_bytes > 0) {
C
Chris Mason 已提交
738
		cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
739
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
740
					   root->sectorsize, 0, alloc_hint,
741
					   (u64)-1, &ins, 1);
C
Chris Mason 已提交
742 743
		BUG_ON(ret);

744 745
		em = alloc_extent_map(GFP_NOFS);
		em->start = start;
746
		em->orig_start = em->start;
C
Chris Mason 已提交
747

748 749
		ram_size = ins.offset;
		em->len = ins.offset;
C
Chris Mason 已提交
750

751
		em->block_start = ins.objectid;
C
Chris Mason 已提交
752
		em->block_len = ins.offset;
753
		em->bdev = root->fs_info->fs_devices->latest_bdev;
754
		set_bit(EXTENT_FLAG_PINNED, &em->flags);
C
Chris Mason 已提交
755

C
Chris Mason 已提交
756
		while (1) {
757 758 759 760 761 762 763 764
			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 已提交
765
						start + ram_size - 1, 0);
766 767
		}

768
		cur_alloc_size = ins.offset;
769
		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
770
					       ram_size, cur_alloc_size, 0);
771
		BUG_ON(ret);
C
Chris Mason 已提交
772

773 774 775 776 777 778 779
		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 已提交
780
		if (disk_num_bytes < cur_alloc_size)
781
			break;
C
Chris Mason 已提交
782

C
Chris Mason 已提交
783 784 785 786 787 788
		/* 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,
789 790
					     locked_page, unlock, 1,
					     1, 0, 0, 0);
C
Chris Mason 已提交
791
		disk_num_bytes -= cur_alloc_size;
792 793 794
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
795 796
	}
out:
797
	ret = 0;
798
	btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
799

800
	return ret;
801
}
C
Chris Mason 已提交
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 837 838 839 840
/*
 * 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 已提交
841
	if (async_cow->inode)
842 843
		submit_compressed_extents(async_cow->inode, async_cow);
}
C
Chris Mason 已提交
844

845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
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;

	if (!btrfs_test_opt(root, COMPRESS)) {
		return cow_file_range(inode, locked_page, start, end,
				      page_started, nr_written, 1);
	}

	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED |
			 EXTENT_DELALLOC, 1, 0, GFP_NOFS);
C
Chris Mason 已提交
869
	while (start < end) {
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
		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 已提交
902
		while (atomic_read(&root->fs_info->async_submit_draining) &&
903 904 905 906 907 908 909 910 911 912 913
		      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;
914 915
}

C
Chris Mason 已提交
916
static noinline int csum_exist_in_range(struct btrfs_root *root,
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
					u64 bytenr, u64 num_bytes)
{
	int ret;
	struct btrfs_ordered_sum *sums;
	LIST_HEAD(list);

	ret = btrfs_lookup_csums_range(root, bytenr, bytenr + num_bytes - 1,
				       &list);
	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 已提交
936 937 938 939 940 941 942
/*
 * 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
 */
C
Chris Mason 已提交
943
static int run_delalloc_nocow(struct inode *inode, struct page *locked_page,
944 945
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
946 947
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
948
	struct btrfs_trans_handle *trans;
949 950
	struct extent_buffer *leaf;
	struct btrfs_path *path;
Y
Yan Zheng 已提交
951
	struct btrfs_file_extent_item *fi;
952
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
953 954 955 956 957 958 959
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
	u64 disk_bytenr;
	u64 num_bytes;
	int extent_type;
	int ret;
Y
Yan Zheng 已提交
960
	int type;
Y
Yan Zheng 已提交
961 962
	int nocow;
	int check_prev = 1;
963 964 965

	path = btrfs_alloc_path();
	BUG_ON(!path);
966 967
	trans = btrfs_join_transaction(root, 1);
	BUG_ON(!trans);
968

Y
Yan Zheng 已提交
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
	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];
		}
994

Y
Yan Zheng 已提交
995 996
		nocow = 0;
		disk_bytenr = 0;
997
		num_bytes = 0;
Y
Yan Zheng 已提交
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
		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 已提交
1014 1015
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
1016 1017 1018 1019 1020 1021 1022
			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;
			}
1023 1024
			if (disk_bytenr == 0)
				goto out_check;
Y
Yan Zheng 已提交
1025 1026 1027 1028
			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 已提交
1029 1030
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1031
			if (btrfs_extent_readonly(root, disk_bytenr))
Y
Yan Zheng 已提交
1032
				goto out_check;
1033 1034 1035
			if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
						  disk_bytenr))
				goto out_check;
Y
Yan Zheng 已提交
1036
			disk_bytenr += btrfs_file_extent_offset(leaf, fi);
1037 1038 1039 1040 1041 1042 1043 1044 1045
			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 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
			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;
1067 1068 1069
		}

		btrfs_release_path(root, path);
Y
Yan Zheng 已提交
1070 1071
		if (cow_start != (u64)-1) {
			ret = cow_file_range(inode, locked_page, cow_start,
1072 1073
					found_key.offset - 1, page_started,
					nr_written, 1);
Y
Yan Zheng 已提交
1074 1075
			BUG_ON(ret);
			cow_start = (u64)-1;
1076
		}
Y
Yan Zheng 已提交
1077

Y
Yan Zheng 已提交
1078 1079 1080 1081 1082 1083
		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;
1084
			em->orig_start = em->start;
Y
Yan Zheng 已提交
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
			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 已提交
1105 1106

		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
Y
Yan Zheng 已提交
1107 1108
					       num_bytes, num_bytes, type);
		BUG_ON(ret);
1109

Y
Yan Zheng 已提交
1110 1111
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					cur_offset, cur_offset + num_bytes - 1,
1112
					locked_page, 1, 1, 1, 0, 0, 0);
Y
Yan Zheng 已提交
1113 1114 1115
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1116
	}
Y
Yan Zheng 已提交
1117 1118 1119 1120 1121 1122
	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,
1123
				     page_started, nr_written, 1);
Y
Yan Zheng 已提交
1124 1125 1126 1127 1128
		BUG_ON(ret);
	}

	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
1129
	btrfs_free_path(path);
Y
Yan Zheng 已提交
1130
	return 0;
1131 1132
}

C
Chris Mason 已提交
1133 1134 1135
/*
 * extent_io.c call back to do delayed allocation processing
 */
C
Chris Mason 已提交
1136
static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1137 1138
			      u64 start, u64 end, int *page_started,
			      unsigned long *nr_written)
1139 1140
{
	int ret;
1141

1142
	if (btrfs_test_flag(inode, NODATACOW))
C
Chris Mason 已提交
1143
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1144
					 page_started, 1, nr_written);
Y
Yan Zheng 已提交
1145 1146
	else if (btrfs_test_flag(inode, PREALLOC))
		ret = run_delalloc_nocow(inode, locked_page, start, end,
C
Chris Mason 已提交
1147
					 page_started, 0, nr_written);
1148
	else
1149
		ret = cow_file_range_async(inode, locked_page, start, end,
C
Chris Mason 已提交
1150
					   page_started, nr_written);
1151

1152 1153 1154
	return ret;
}

C
Chris Mason 已提交
1155 1156 1157 1158 1159
/*
 * 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.
 */
1160
static int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
C
Chris Mason 已提交
1161
		       unsigned long old, unsigned long bits)
1162
{
1163 1164 1165 1166 1167
	/*
	 * 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 已提交
1168
	if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
1169
		struct btrfs_root *root = BTRFS_I(inode)->root;
1170
		spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
1171
		BTRFS_I(inode)->delalloc_bytes += end - start + 1;
1172
		root->fs_info->delalloc_bytes += end - start + 1;
1173 1174 1175 1176
		if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
			list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
				      &root->fs_info->delalloc_inodes);
		}
1177
		spin_unlock(&root->fs_info->delalloc_lock);
1178 1179 1180 1181
	}
	return 0;
}

C
Chris Mason 已提交
1182 1183 1184
/*
 * extent_io.c clear_bit_hook, see set_bit_hook for why
 */
1185
static int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
C
Chris Mason 已提交
1186
			 unsigned long old, unsigned long bits)
1187
{
1188 1189 1190 1191 1192
	/*
	 * 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 已提交
1193
	if ((old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
1194
		struct btrfs_root *root = BTRFS_I(inode)->root;
1195

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

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

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

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

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

C
Chris Mason 已提交
1247 1248 1249 1250 1251 1252 1253 1254
/*
 * 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 已提交
1255 1256 1257
static int __btrfs_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
				    unsigned long bio_flags)
1258 1259 1260
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1261

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

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

C
Chris Mason 已提交
1282
/*
1283 1284
 * 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 已提交
1285
 */
1286
static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
1287
			  int mirror_num, unsigned long bio_flags)
1288 1289 1290
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
1291
	int skip_sum;
1292

1293 1294
	skip_sum = btrfs_test_flag(inode, NODATASUM);

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

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

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

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

	btrfs_set_trans_block_group(trans, inode);
1332
	list_for_each(cur, list) {
1333
		sum = list_entry(cur, struct btrfs_ordered_sum, list);
1334 1335
		btrfs_csum_file_blocks(trans,
		       BTRFS_I(inode)->root->fs_info->csum_root, sum);
1336 1337 1338 1339
	}
	return 0;
}

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

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

1354
static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
{
	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 已提交
1365
again:
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
	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 已提交
1377 1378 1379 1380

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

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

1393
	btrfs_set_extent_delalloc(inode, page_start, page_end);
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
	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 已提交
1408
 * In our case any range that doesn't have the ORDERED bit set
1409 1410 1411 1412
 * 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.
 */
1413
static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
{
	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;
1431

1432 1433 1434 1435 1436 1437 1438 1439
	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 已提交
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
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);

	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);
	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);
	return 0;
}

C
Chris Mason 已提交
1497 1498 1499 1500
/* 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.
 */
1501
static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
1502 1503 1504 1505 1506
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	struct btrfs_ordered_extent *ordered_extent;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
Y
Yan Zheng 已提交
1507
	int compressed = 0;
1508 1509 1510
	int ret;

	ret = btrfs_dec_test_ordered_pending(inode, start, end - start + 1);
1511
	if (!ret)
1512 1513
		return 0;

1514
	trans = btrfs_join_transaction(root, 1);
1515 1516 1517

	ordered_extent = btrfs_lookup_ordered_extent(inode, start);
	BUG_ON(!ordered_extent);
1518 1519
	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags))
		goto nocow;
1520 1521 1522 1523 1524

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

C
Chris Mason 已提交
1525
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
Y
Yan Zheng 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544
		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);
	}
1545 1546 1547
	unlock_extent(io_tree, ordered_extent->file_offset,
		    ordered_extent->file_offset + ordered_extent->len - 1,
		    GFP_NOFS);
1548
nocow:
1549 1550 1551
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

1552
	mutex_lock(&BTRFS_I(inode)->extent_mutex);
1553
	btrfs_ordered_update_i_size(inode, ordered_extent);
1554
	btrfs_update_inode(trans, root, inode);
1555
	btrfs_remove_ordered_extent(inode, ordered_extent);
1556
	mutex_unlock(&BTRFS_I(inode)->extent_mutex);
1557

1558 1559 1560 1561 1562 1563 1564 1565 1566
	/* 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;
}

1567
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1568 1569 1570 1571 1572
				struct extent_state *state, int uptodate)
{
	return btrfs_finish_ordered_io(page->mapping->host, start, end);
}

C
Chris Mason 已提交
1573 1574 1575 1576 1577 1578 1579 1580
/*
 * 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.
 */
1581 1582 1583 1584 1585
struct io_failure_record {
	struct page *page;
	u64 start;
	u64 len;
	u64 logical;
1586
	unsigned long bio_flags;
1587 1588 1589
	int last_mirror;
};

1590
static int btrfs_io_failed_hook(struct bio *failed_bio,
1591 1592
			 struct page *page, u64 start, u64 end,
			 struct extent_state *state)
1593 1594 1595 1596 1597 1598
{
	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;
1599
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1600 1601 1602
	struct bio *bio;
	int num_copies;
	int ret;
1603
	int rw;
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
	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;
1614
		failrec->bio_flags = 0;
1615

1616 1617 1618 1619 1620 1621 1622
		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);
1623 1624 1625 1626 1627 1628 1629

		if (!em || IS_ERR(em)) {
			kfree(failrec);
			return -EIO;
		}
		logical = start - em->start;
		logical = em->block_start + logical;
1630 1631 1632 1633
		if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
			logical = em->block_start;
			failrec->bio_flags = EXTENT_BIO_COMPRESSED;
		}
1634 1635 1636 1637
		failrec->logical = logical;
		free_extent_map(em);
		set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
				EXTENT_DIRTY, GFP_NOFS);
1638 1639
		set_state_private(failure_tree, start,
				 (u64)(unsigned long)failrec);
1640
	} else {
1641
		failrec = (struct io_failure_record *)(unsigned long)private;
1642 1643 1644 1645 1646 1647
	}
	num_copies = btrfs_num_copies(
			      &BTRFS_I(inode)->root->fs_info->mapping_tree,
			      failrec->logical, failrec->len);
	failrec->last_mirror++;
	if (!state) {
1648
		spin_lock(&BTRFS_I(inode)->io_tree.lock);
1649 1650 1651 1652 1653
		state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
						    failrec->start,
						    EXTENT_LOCKED);
		if (state && state->start != failrec->start)
			state = NULL;
1654
		spin_unlock(&BTRFS_I(inode)->io_tree.lock);
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	}
	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;
1669
	bio->bi_size = 0;
1670

1671
	bio_add_page(bio, page, failrec->len, start - page_offset(page));
1672 1673 1674 1675 1676 1677
	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 已提交
1678
						      failrec->last_mirror,
1679
						      failrec->bio_flags);
1680 1681 1682
	return 0;
}

C
Chris Mason 已提交
1683 1684 1685 1686
/*
 * 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
 */
1687
static int btrfs_clean_io_failures(struct inode *inode, u64 start)
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
{
	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);
		}
	}
1712 1713 1714
	return 0;
}

C
Chris Mason 已提交
1715 1716 1717 1718 1719
/*
 * 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
 */
1720
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1721
			       struct extent_state *state)
1722
{
1723
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1724
	struct inode *inode = page->mapping->host;
1725
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1726
	char *kaddr;
1727
	u64 private = ~(u32)0;
1728
	int ret;
1729 1730
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
1731
	unsigned long flags;
1732

1733 1734 1735 1736
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
1737 1738 1739 1740 1741 1742 1743
	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);
1744
		return 0;
1745
	}
1746

Y
Yan 已提交
1747
	if (state && state->start == start) {
1748 1749 1750 1751 1752
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
1753
	local_irq_save(flags);
1754
	kaddr = kmap_atomic(page, KM_IRQ0);
C
Chris Mason 已提交
1755
	if (ret)
1756
		goto zeroit;
C
Chris Mason 已提交
1757

1758 1759
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
C
Chris Mason 已提交
1760
	if (csum != private)
1761
		goto zeroit;
C
Chris Mason 已提交
1762

1763
	kunmap_atomic(kaddr, KM_IRQ0);
1764
	local_irq_restore(flags);
1765
good:
1766 1767 1768
	/* if the io failure tree for this inode is non-empty,
	 * check to see if we've recovered from a failed IO
	 */
1769
	btrfs_clean_io_failures(inode, start);
1770 1771 1772
	return 0;

zeroit:
C
Chris Mason 已提交
1773 1774 1775 1776
	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);
1777 1778
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
1779
	kunmap_atomic(kaddr, KM_IRQ0);
1780
	local_irq_restore(flags);
1781 1782
	if (private == 0)
		return 0;
1783
	return -EIO;
1784
}
1785

1786 1787 1788 1789 1790 1791 1792 1793 1794
/*
 * 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;

1795
	spin_lock(&root->list_lock);
1796 1797 1798

	/* already on the orphan list, we're good */
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
1799
		spin_unlock(&root->list_lock);
1800 1801 1802 1803 1804
		return 0;
	}

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

1805
	spin_unlock(&root->list_lock);
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823

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

1824
	spin_lock(&root->list_lock);
1825 1826

	if (list_empty(&BTRFS_I(inode)->i_orphan)) {
1827
		spin_unlock(&root->list_lock);
1828 1829 1830 1831 1832
		return 0;
	}

	list_del_init(&BTRFS_I(inode)->i_orphan);
	if (!trans) {
1833
		spin_unlock(&root->list_lock);
1834 1835 1836
		return 0;
	}

1837
	spin_unlock(&root->list_lock);
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905

	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.
		 */
1906
		inode = btrfs_iget_locked(root->fs_info->sb,
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
					  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
		 */
1927
		spin_lock(&root->list_lock);
1928
		list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
1929
		spin_unlock(&root->list_lock);
1930 1931 1932 1933 1934 1935 1936 1937

		/*
		 * 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)) {
1938
			trans = btrfs_start_transaction(root, 1);
1939
			btrfs_orphan_del(trans, inode);
1940
			btrfs_end_transaction(trans, root);
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964
			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 已提交
1965 1966 1967
/*
 * read an inode from the btree into the in-memory inode
 */
C
Chris Mason 已提交
1968 1969 1970
void btrfs_read_locked_inode(struct inode *inode)
{
	struct btrfs_path *path;
1971
	struct extent_buffer *leaf;
C
Chris Mason 已提交
1972
	struct btrfs_inode_item *inode_item;
1973
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
1974 1975 1976
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
	u64 alloc_group_block;
J
Josef Bacik 已提交
1977
	u32 rdev;
C
Chris Mason 已提交
1978 1979 1980 1981 1982
	int ret;

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

C
Chris Mason 已提交
1984
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
1985
	if (ret)
C
Chris Mason 已提交
1986 1987
		goto make_bad;

1988 1989 1990 1991 1992 1993 1994 1995
	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);
1996
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009

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

2010
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2011
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2012
	BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2013
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
2014
	inode->i_rdev = 0;
2015 2016
	rdev = btrfs_inode_rdev(leaf, inode_item);

2017
	BTRFS_I(inode)->index_cnt = (u64)-1;
2018
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2019

2020
	alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
2021 2022
	BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
						alloc_group_block, 0);
C
Chris Mason 已提交
2023 2024 2025 2026 2027 2028
	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 已提交
2029
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2030
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043
		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 已提交
2044
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
2045
		break;
J
Josef Bacik 已提交
2046 2047 2048
	default:
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
2049 2050 2051 2052 2053 2054 2055 2056
	}
	return;

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

C
Chris Mason 已提交
2057 2058 2059
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
2060 2061
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
2062
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
2063 2064
			    struct inode *inode)
{
2065 2066
	btrfs_set_inode_uid(leaf, item, inode->i_uid);
	btrfs_set_inode_gid(leaf, item, inode->i_gid);
2067
	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
	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);

2086
	btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2087
	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2088
	btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2089
	btrfs_set_inode_transid(leaf, item, trans->transid);
2090
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
Y
Yan 已提交
2091
	btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2092
	btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
C
Chris Mason 已提交
2093 2094
}

C
Chris Mason 已提交
2095 2096 2097
/*
 * copy everything in the in-memory inode into the btree.
 */
C
Chris Mason 已提交
2098 2099
noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
2100 2101 2102
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
2103
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, 1);
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

2116 2117
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2118 2119
				  struct btrfs_inode_item);

2120
	fill_inode_item(trans, leaf, inode_item, inode);
2121
	btrfs_mark_buffer_dirty(leaf);
2122
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
2123 2124 2125 2126 2127 2128 2129
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}


C
Chris Mason 已提交
2130 2131 2132 2133 2134
/*
 * 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
 */
2135 2136 2137 2138
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 已提交
2139 2140 2141
{
	struct btrfs_path *path;
	int ret = 0;
2142
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2143
	struct btrfs_dir_item *di;
2144
	struct btrfs_key key;
2145
	u64 index;
C
Chris Mason 已提交
2146 2147

	path = btrfs_alloc_path();
2148 2149 2150 2151 2152
	if (!path) {
		ret = -ENOMEM;
		goto err;
	}

C
Chris Mason 已提交
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
	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;
	}
2163 2164
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
2165
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2166 2167
	if (ret)
		goto err;
C
Chris Mason 已提交
2168 2169
	btrfs_release_path(root, path);

2170
	ret = btrfs_del_inode_ref(trans, root, name, name_len,
2171 2172
				  inode->i_ino,
				  dir->i_ino, &index);
2173
	if (ret) {
C
Chris Mason 已提交
2174
		printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2175
		       "inode %lu parent %lu\n", name_len, name,
2176
		       inode->i_ino, dir->i_ino);
2177 2178 2179
		goto err;
	}

C
Chris Mason 已提交
2180
	di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
2181
					 index, name, name_len, -1);
C
Chris Mason 已提交
2182 2183 2184 2185 2186 2187 2188 2189 2190
	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);
2191
	btrfs_release_path(root, path);
C
Chris Mason 已提交
2192

2193 2194
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
					 inode, dir->i_ino);
C
Chris Mason 已提交
2195 2196 2197
	BUG_ON(ret != 0 && ret != -ENOENT);
	if (ret != -ENOENT)
		BTRFS_I(dir)->log_dirty_trans = trans->transid;
2198 2199 2200 2201

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
	BUG_ON(ret);
C
Chris Mason 已提交
2202 2203
err:
	btrfs_free_path(path);
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
	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 已提交
2214 2215 2216 2217 2218 2219 2220
	return ret;
}

static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root;
	struct btrfs_trans_handle *trans;
2221
	struct inode *inode = dentry->d_inode;
C
Chris Mason 已提交
2222
	int ret;
2223
	unsigned long nr = 0;
C
Chris Mason 已提交
2224 2225

	root = BTRFS_I(dir)->root;
2226 2227 2228 2229 2230

	ret = btrfs_check_free_space(root, 1, 1);
	if (ret)
		goto fail;

C
Chris Mason 已提交
2231
	trans = btrfs_start_transaction(root, 1);
2232

C
Chris Mason 已提交
2233
	btrfs_set_trans_block_group(trans, dir);
2234 2235
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
2236 2237 2238 2239

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

2240
	nr = trans->blocks_used;
2241

2242
	btrfs_end_transaction_throttle(trans, root);
2243
fail:
2244
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2245 2246 2247 2248 2249 2250
	return ret;
}

static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
2251
	int err = 0;
C
Chris Mason 已提交
2252 2253 2254
	int ret;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
2255
	unsigned long nr = 0;
C
Chris Mason 已提交
2256

2257 2258 2259 2260 2261 2262
	/*
	 * 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 已提交
2263
		return -ENOTEMPTY;
2264
	}
Y
Yan 已提交
2265

2266 2267 2268 2269
	ret = btrfs_check_free_space(root, 1, 1);
	if (ret)
		goto fail;

C
Chris Mason 已提交
2270 2271 2272
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

2273 2274 2275 2276
	err = btrfs_orphan_add(trans, inode);
	if (err)
		goto fail_trans;

C
Chris Mason 已提交
2277
	/* now the directory is empty */
2278 2279
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
C
Chris Mason 已提交
2280
	if (!err)
2281
		btrfs_i_size_write(inode, 0);
2282

2283
fail_trans:
2284
	nr = trans->blocks_used;
2285
	ret = btrfs_end_transaction_throttle(trans, root);
2286
fail:
2287
	btrfs_btree_balance_dirty(root, nr);
2288

C
Chris Mason 已提交
2289 2290 2291 2292 2293
	if (ret && !err)
		err = ret;
	return err;
}

2294
#if 0
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322
/*
 * 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 已提交
2323 2324 2325
	struct btrfs_leaf_ref *ref;
	u64 leaf_gen;
	u64 leaf_start;
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418

	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 已提交
2419 2420
	leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);
	leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);
2421 2422 2423 2424
	/*
	 * it is safe to delete this leaf, it contains only
	 * csum items from this inode at an offset >= new_size
	 */
Y
Yan Zheng 已提交
2425
	ret = btrfs_del_leaf(trans, root, path, leaf_start);
2426 2427
	BUG_ON(ret);

Y
Yan Zheng 已提交
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
	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;

			ret = btrfs_add_leaf_ref(root, ref, 0);
			WARN_ON(ret);
			btrfs_free_leaf_ref(root, ref);
		} else {
			WARN_ON(1);
		}
	}
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
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;
}

2462 2463
#endif

C
Chris Mason 已提交
2464 2465 2466
/*
 * 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 已提交
2467
 * any higher than new_size
C
Chris Mason 已提交
2468 2469 2470
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
2471 2472 2473
 *
 * 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 已提交
2474
 */
2475 2476 2477 2478
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 已提交
2479 2480 2481 2482
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;
2483
	struct btrfs_key found_key;
C
Chris Mason 已提交
2484
	u32 found_type;
2485
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2486 2487
	struct btrfs_file_extent_item *fi;
	u64 extent_start = 0;
2488
	u64 extent_num_bytes = 0;
C
Chris Mason 已提交
2489
	u64 item_end = 0;
2490
	u64 root_gen = 0;
2491
	u64 root_owner = 0;
C
Chris Mason 已提交
2492 2493
	int found_extent;
	int del_item;
2494 2495
	int pending_del_nr = 0;
	int pending_del_slot = 0;
2496
	int extent_type = -1;
2497
	int encoding;
2498
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
2499

2500
	if (root->ref_cows)
2501
		btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
C
Chris Mason 已提交
2502
	path = btrfs_alloc_path();
2503
	path->reada = -1;
C
Chris Mason 已提交
2504
	BUG_ON(!path);
2505

C
Chris Mason 已提交
2506 2507 2508
	/* FIXME, add redo link to tree so we don't leak on crash */
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
2509 2510
	key.type = (u8)-1;

2511
	btrfs_init_path(path);
2512

2513 2514
search_again:
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
C
Chris Mason 已提交
2515
	if (ret < 0)
2516
		goto error;
C
Chris Mason 已提交
2517

2518
	if (ret > 0) {
2519 2520 2521 2522 2523 2524 2525
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
		if (path->slots[0] == 0) {
			ret = 0;
			goto error;
		}
2526 2527 2528
		path->slots[0]--;
	}

C
Chris Mason 已提交
2529
	while (1) {
C
Chris Mason 已提交
2530
		fi = NULL;
2531 2532 2533
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		found_type = btrfs_key_type(&found_key);
2534
		encoding = 0;
C
Chris Mason 已提交
2535

2536
		if (found_key.objectid != inode->i_ino)
C
Chris Mason 已提交
2537
			break;
2538

2539
		if (found_type < min_type)
C
Chris Mason 已提交
2540 2541
			break;

2542
		item_end = found_key.offset;
C
Chris Mason 已提交
2543
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
2544
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2545
					    struct btrfs_file_extent_item);
2546
			extent_type = btrfs_file_extent_type(leaf, fi);
2547 2548 2549 2550
			encoding = btrfs_file_extent_compression(leaf, fi);
			encoding |= btrfs_file_extent_encryption(leaf, fi);
			encoding |= btrfs_file_extent_other_encoding(leaf, fi);

2551
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
2552
				item_end +=
2553
				    btrfs_file_extent_num_bytes(leaf, fi);
2554 2555
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
C
Chris Mason 已提交
2556
									 fi);
C
Chris Mason 已提交
2557
			}
2558
			item_end--;
C
Chris Mason 已提交
2559
		}
2560
		if (item_end < new_size) {
C
Chris Mason 已提交
2561
			if (found_type == BTRFS_DIR_ITEM_KEY)
2562
				found_type = BTRFS_INODE_ITEM_KEY;
C
Chris Mason 已提交
2563
			else if (found_type == BTRFS_EXTENT_ITEM_KEY)
2564
				found_type = BTRFS_EXTENT_DATA_KEY;
C
Chris Mason 已提交
2565
			else if (found_type == BTRFS_EXTENT_DATA_KEY)
2566
				found_type = BTRFS_XATTR_ITEM_KEY;
C
Chris Mason 已提交
2567
			else if (found_type == BTRFS_XATTR_ITEM_KEY)
2568
				found_type = BTRFS_INODE_REF_KEY;
C
Chris Mason 已提交
2569
			else if (found_type)
2570
				found_type--;
C
Chris Mason 已提交
2571
			else
2572
				break;
2573
			btrfs_set_key_type(&key, found_type);
2574
			goto next;
C
Chris Mason 已提交
2575
		}
2576
		if (found_key.offset >= new_size)
C
Chris Mason 已提交
2577 2578 2579 2580 2581 2582
			del_item = 1;
		else
			del_item = 0;
		found_extent = 0;

		/* FIXME, shrink the extent if the ref count is only 1 */
2583 2584 2585 2586
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2587
			u64 num_dec;
2588
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
2589
			if (!del_item && !encoding) {
2590 2591
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
2592
				extent_num_bytes = new_size -
2593
					found_key.offset + root->sectorsize - 1;
2594 2595
				extent_num_bytes = extent_num_bytes &
					~((u64)root->sectorsize - 1);
2596 2597 2598
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
C
Chris Mason 已提交
2599
					   extent_num_bytes);
2600
				if (root->ref_cows && extent_start != 0)
2601
					inode_sub_bytes(inode, num_dec);
2602
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2603
			} else {
2604 2605 2606
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
C
Chris Mason 已提交
2607
				/* FIXME blocksize != 4096 */
C
Chris Mason 已提交
2608
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
2609 2610
				if (extent_start != 0) {
					found_extent = 1;
2611
					if (root->ref_cows)
2612
						inode_sub_bytes(inode, num_dec);
2613
				}
Z
Zheng Yan 已提交
2614
				root_gen = btrfs_header_generation(leaf);
2615
				root_owner = btrfs_header_owner(leaf);
C
Chris Mason 已提交
2616
			}
C
Chris Mason 已提交
2617
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2618 2619 2620 2621 2622 2623 2624 2625
			/*
			 * 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) {
2626 2627 2628
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
2629 2630
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
2631 2632 2633
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
C
Chris Mason 已提交
2634
				ret = btrfs_truncate_item(trans, root, path,
2635
							  size, 1);
C
Chris Mason 已提交
2636
				BUG_ON(ret);
2637
			} else if (root->ref_cows) {
2638 2639
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
C
Chris Mason 已提交
2640
			}
C
Chris Mason 已提交
2641
		}
2642
delete:
C
Chris Mason 已提交
2643
		if (del_item) {
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
			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 已提交
2654
				BUG();
2655
			}
C
Chris Mason 已提交
2656 2657 2658 2659 2660
		} else {
			break;
		}
		if (found_extent) {
			ret = btrfs_free_extent(trans, root, extent_start,
2661
						extent_num_bytes,
Z
Zheng Yan 已提交
2662
						leaf->start, root_owner,
2663
						root_gen, inode->i_ino, 0);
C
Chris Mason 已提交
2664 2665
			BUG_ON(ret);
		}
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688
next:
		if (path->slots[0] == 0) {
			if (pending_del_nr)
				goto del_pending;
			btrfs_release_path(root, path);
			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);
			goto search_again;
		}
C
Chris Mason 已提交
2689 2690 2691
	}
	ret = 0;
error:
2692 2693 2694 2695
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
	}
C
Chris Mason 已提交
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707
	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;
2708
	struct btrfs_root *root = BTRFS_I(inode)->root;
2709 2710 2711
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
	char *kaddr;
2712
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
2713 2714 2715 2716
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
	int ret = 0;
2717
	u64 page_start;
2718
	u64 page_end;
C
Chris Mason 已提交
2719 2720 2721 2722 2723

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

	ret = -ENOMEM;
2724
again:
C
Chris Mason 已提交
2725 2726 2727
	page = grab_cache_page(mapping, index);
	if (!page)
		goto out;
2728 2729 2730 2731

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

C
Chris Mason 已提交
2732
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
2733
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
2734
		lock_page(page);
2735 2736 2737 2738 2739
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
2740 2741
		if (!PageUptodate(page)) {
			ret = -EIO;
2742
			goto out_unlock;
C
Chris Mason 已提交
2743 2744
		}
	}
2745
	wait_on_page_writeback(page);
2746 2747 2748 2749 2750 2751 2752 2753 2754

	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);
2755
		btrfs_start_ordered_extent(inode, ordered, 1);
2756 2757 2758 2759
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

2760
	btrfs_set_extent_delalloc(inode, page_start, page_end);
2761 2762 2763 2764 2765 2766 2767
	ret = 0;
	if (offset != PAGE_CACHE_SIZE) {
		kaddr = kmap(page);
		memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
		flush_dcache_page(page);
		kunmap(page);
	}
2768
	ClearPageChecked(page);
2769 2770
	set_page_dirty(page);
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
2771

2772
out_unlock:
C
Chris Mason 已提交
2773 2774 2775 2776 2777 2778
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

Y
Yan Zheng 已提交
2779
int btrfs_cont_expand(struct inode *inode, loff_t size)
C
Chris Mason 已提交
2780
{
Y
Yan Zheng 已提交
2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
	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 已提交
2791 2792
	int err;

Y
Yan Zheng 已提交
2793 2794 2795 2796
	if (size <= hole_start)
		return 0;

	err = btrfs_check_free_space(root, 1, 0);
C
Chris Mason 已提交
2797 2798 2799
	if (err)
		return err;

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

Y
Yan Zheng 已提交
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
	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 已提交
2813

Y
Yan Zheng 已提交
2814 2815
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
C
Chris Mason 已提交
2816

Y
Yan Zheng 已提交
2817 2818 2819 2820 2821 2822 2823 2824
	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)) {
2825
			u64 hint_byte = 0;
Y
Yan Zheng 已提交
2826
			hole_size = last_byte - cur_offset;
2827 2828 2829 2830 2831 2832
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
						 cur_offset + hole_size,
						 cur_offset, &hint_byte);
			if (err)
				break;
Y
Yan Zheng 已提交
2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
			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;
	}
2845

Y
Yan Zheng 已提交
2846 2847 2848 2849
	btrfs_end_transaction(trans, root);
	unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
	return err;
}
C
Chris Mason 已提交
2850

Y
Yan Zheng 已提交
2851 2852 2853 2854
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int err;
C
Chris Mason 已提交
2855

Y
Yan Zheng 已提交
2856 2857 2858
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
2859

Y
Yan Zheng 已提交
2860 2861 2862
	if (S_ISREG(inode->i_mode) &&
	    attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
		err = btrfs_cont_expand(inode, attr->ia_size);
2863 2864
		if (err)
			return err;
C
Chris Mason 已提交
2865
	}
Y
Yan Zheng 已提交
2866

C
Chris Mason 已提交
2867
	err = inode_setattr(inode, attr);
J
Josef Bacik 已提交
2868 2869 2870

	if (!err && ((attr->ia_valid & ATTR_MODE)))
		err = btrfs_acl_chmod(inode);
C
Chris Mason 已提交
2871 2872
	return err;
}
2873

C
Chris Mason 已提交
2874 2875 2876 2877
void btrfs_delete_inode(struct inode *inode)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
2878
	unsigned long nr;
C
Chris Mason 已提交
2879 2880 2881 2882
	int ret;

	truncate_inode_pages(&inode->i_data, 0);
	if (is_bad_inode(inode)) {
2883
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
2884 2885
		goto no_delete;
	}
C
Chris Mason 已提交
2886
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
2887

2888
	btrfs_i_size_write(inode, 0);
2889
	trans = btrfs_join_transaction(root, 1);
2890

C
Chris Mason 已提交
2891
	btrfs_set_trans_block_group(trans, inode);
2892
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size, 0);
2893 2894
	if (ret) {
		btrfs_orphan_del(NULL, inode);
2895
		goto no_delete_lock;
2896 2897 2898
	}

	btrfs_orphan_del(trans, inode);
2899

2900
	nr = trans->blocks_used;
2901
	clear_inode(inode);
2902

C
Chris Mason 已提交
2903
	btrfs_end_transaction(trans, root);
2904
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2905
	return;
2906 2907

no_delete_lock:
2908
	nr = trans->blocks_used;
2909
	btrfs_end_transaction(trans, root);
2910
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926
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 已提交
2927
	int ret = 0;
C
Chris Mason 已提交
2928 2929 2930

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

C
Chris Mason 已提交
2932 2933
	di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
				    namelen, 0);
Y
Yan 已提交
2934 2935
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
2936 2937

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

2940
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
2941 2942 2943
out:
	btrfs_free_path(path);
	return ret;
2944 2945 2946
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
2947 2948 2949 2950 2951 2952 2953 2954 2955
}

/*
 * 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,
2956 2957
			     struct btrfs_root **sub_root,
			     struct dentry *dentry)
C
Chris Mason 已提交
2958 2959 2960 2961 2962 2963 2964 2965
{
	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;

2966 2967 2968
	*sub_root = btrfs_read_fs_root(root->fs_info, location,
					dentry->d_name.name,
					dentry->d_name.len);
C
Chris Mason 已提交
2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979
	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;
}

2980
static noinline void init_btrfs_i(struct inode *inode)
C
Chris Mason 已提交
2981
{
2982 2983 2984 2985 2986 2987
	struct btrfs_inode *bi = BTRFS_I(inode);

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

	bi->generation = 0;
2988
	bi->sequence = 0;
2989 2990 2991 2992 2993 2994
	bi->last_trans = 0;
	bi->logged_trans = 0;
	bi->delalloc_bytes = 0;
	bi->disk_i_size = 0;
	bi->flags = 0;
	bi->index_cnt = (u64)-1;
C
Chris Mason 已提交
2995
	bi->log_dirty_trans = 0;
2996 2997
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
	extent_io_tree_init(&BTRFS_I(inode)->io_tree,
2998
			     inode->i_mapping, GFP_NOFS);
2999 3000
	extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
			     inode->i_mapping, GFP_NOFS);
3001
	INIT_LIST_HEAD(&BTRFS_I(inode)->delalloc_inodes);
3002
	btrfs_ordered_inode_tree_init(&BTRFS_I(inode)->ordered_tree);
3003
	mutex_init(&BTRFS_I(inode)->extent_mutex);
3004 3005 3006 3007 3008 3009 3010 3011 3012
	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;
C
Chris Mason 已提交
3013 3014 3015 3016 3017 3018
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
C
Chris Mason 已提交
3019 3020
	return args->ino == inode->i_ino &&
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
3021 3022
}

3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040
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 已提交
3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
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 已提交
3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081
/* 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;
}

3082
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
3083
{
C
Chris Mason 已提交
3084
	struct inode *inode;
C
Chris Mason 已提交
3085 3086 3087 3088
	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 已提交
3089
	int ret, new;
C
Chris Mason 已提交
3090 3091 3092

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

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

C
Chris Mason 已提交
3096 3097
	if (ret < 0)
		return ERR_PTR(ret);
3098

C
Chris Mason 已提交
3099 3100
	inode = NULL;
	if (location.objectid) {
3101 3102
		ret = fixup_tree_root_location(root, &location, &sub_root,
						dentry);
C
Chris Mason 已提交
3103 3104 3105 3106
		if (ret < 0)
			return ERR_PTR(ret);
		if (ret > 0)
			return ERR_PTR(-ENOENT);
B
Balaji Rao 已提交
3107 3108 3109
		inode = btrfs_iget(dir->i_sb, &location, sub_root, &new);
		if (IS_ERR(inode))
			return ERR_CAST(inode);
C
Chris Mason 已提交
3110
	}
3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124
	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);
3125

C
Chris Mason 已提交
3126 3127 3128 3129 3130 3131 3132
	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
};

3133 3134
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
3135
{
3136
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
3137 3138 3139 3140
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
3141
	struct btrfs_key found_key;
C
Chris Mason 已提交
3142 3143 3144
	struct btrfs_path *path;
	int ret;
	u32 nritems;
3145
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3146 3147 3148 3149 3150 3151 3152 3153
	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;
3154 3155 3156
	char tmp_name[32];
	char *name_ptr;
	int name_len;
C
Chris Mason 已提交
3157 3158 3159 3160

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

3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172
	/* 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) {
3173
		u64 pino = parent_ino(filp->f_path.dentry);
3174
		over = filldir(dirent, "..", 2,
3175
			       2, pino, DT_DIR);
3176
		if (over)
3177
			return 0;
3178 3179
		filp->f_pos = 2;
	}
3180 3181 3182
	path = btrfs_alloc_path();
	path->reada = 2;

C
Chris Mason 已提交
3183 3184
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
3185
	key.objectid = inode->i_ino;
3186

C
Chris Mason 已提交
3187 3188 3189 3190
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
	advance = 0;
3191 3192

	while (1) {
3193 3194
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3195 3196
		slot = path->slots[0];
		if (advance || slot >= nritems) {
3197
			if (slot >= nritems - 1) {
C
Chris Mason 已提交
3198 3199 3200
				ret = btrfs_next_leaf(root, path);
				if (ret)
					break;
3201 3202
				leaf = path->nodes[0];
				nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3203 3204 3205 3206 3207 3208
				slot = path->slots[0];
			} else {
				slot++;
				path->slots[0]++;
			}
		}
3209

C
Chris Mason 已提交
3210
		advance = 1;
3211 3212 3213 3214
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
3215
			break;
3216
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
3217
			break;
3218
		if (found_key.offset < filp->f_pos)
C
Chris Mason 已提交
3219
			continue;
3220 3221

		filp->f_pos = found_key.offset;
3222

C
Chris Mason 已提交
3223 3224
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
3225
		di_total = btrfs_item_size(leaf, item);
3226 3227

		while (di_cur < di_total) {
3228 3229 3230
			struct btrfs_key location;

			name_len = btrfs_dir_name_len(leaf, di);
3231
			if (name_len <= sizeof(tmp_name)) {
3232 3233 3234
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
3235 3236 3237 3238
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
3239 3240 3241 3242 3243 3244
			}
			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);
3245 3246 3247 3248 3249 3250 3251 3252 3253

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

3258
skip:
3259 3260 3261
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
3262 3263
			if (over)
				goto nopos;
J
Josef Bacik 已提交
3264
			di_len = btrfs_dir_name_len(leaf, di) +
3265
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
3266 3267 3268 3269
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
	}
3270 3271

	/* Reached end of directory/root. Bump pos past the last item. */
3272 3273 3274 3275
	if (key_type == BTRFS_DIR_INDEX_KEY)
		filp->f_pos = INT_LIMIT(typeof(filp->f_pos));
	else
		filp->f_pos++;
C
Chris Mason 已提交
3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288
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 已提交
3289
	if (root->fs_info->btree_inode == inode)
3290 3291
		return 0;

C
Chris Mason 已提交
3292
	if (wait) {
3293
		trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3294 3295 3296 3297 3298 3299 3300
		btrfs_set_trans_block_group(trans, inode);
		ret = btrfs_commit_transaction(trans, root);
	}
	return ret;
}

/*
3301
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
3302 3303 3304 3305 3306 3307 3308 3309 3310
 * 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;

3311
	trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3312 3313 3314 3315 3316
	btrfs_set_trans_block_group(trans, inode);
	btrfs_update_inode(trans, root, inode);
	btrfs_end_transaction(trans, root);
}

C
Chris Mason 已提交
3317 3318 3319 3320 3321
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373
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 已提交
3374 3375 3376 3377
/*
 * 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
 */
3378
int btrfs_set_inode_index(struct inode *dir, u64 *index)
3379 3380 3381 3382 3383
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
		ret = btrfs_set_inode_index_count(dir);
C
Chris Mason 已提交
3384
		if (ret)
3385 3386 3387
			return ret;
	}

3388
	*index = BTRFS_I(dir)->index_cnt;
3389 3390 3391 3392 3393
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
3394 3395
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
3396
				     struct inode *dir,
3397
				     const char *name, int name_len,
3398 3399
				     u64 ref_objectid, u64 objectid,
				     u64 alloc_hint, int mode, u64 *index)
C
Chris Mason 已提交
3400 3401
{
	struct inode *inode;
3402
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
3403
	struct btrfs_key *location;
3404
	struct btrfs_path *path;
3405 3406 3407 3408
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
3409 3410 3411
	int ret;
	int owner;

3412 3413 3414
	path = btrfs_alloc_path();
	BUG_ON(!path);

C
Chris Mason 已提交
3415 3416 3417 3418
	inode = new_inode(root->fs_info->sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

3419
	if (dir) {
3420
		ret = btrfs_set_inode_index(dir, index);
3421 3422 3423 3424 3425 3426 3427 3428
		if (ret)
			return ERR_PTR(ret);
	}
	/*
	 * index_cnt is ignored for everything but a dir,
	 * btrfs_get_inode_index_count has an explanation for the magic
	 * number
	 */
3429
	init_btrfs_i(inode);
3430
	BTRFS_I(inode)->index_cnt = 2;
C
Chris Mason 已提交
3431
	BTRFS_I(inode)->root = root;
3432
	BTRFS_I(inode)->generation = trans->transid;
3433

C
Chris Mason 已提交
3434 3435 3436 3437
	if (mode & S_IFDIR)
		owner = 0;
	else
		owner = 1;
3438 3439
	BTRFS_I(inode)->block_group =
			btrfs_find_block_group(root, 0, alloc_hint, owner);
3440 3441 3442 3443 3444 3445
	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);
	}
3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459

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

	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
3460 3461
		goto fail;

3462 3463 3464
	if (objectid > root->highest_inode)
		root->highest_inode = objectid;

C
Chris Mason 已提交
3465 3466
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
C
Chris Mason 已提交
3467 3468
	inode->i_mode = mode;
	inode->i_ino = objectid;
3469
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
3470
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
3471 3472
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
3473
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
3474 3475 3476 3477

	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);
3478
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
3479 3480 3481
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

3482 3483 3484
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
3485 3486 3487 3488 3489 3490 3491
	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;
3492
fail:
3493 3494
	if (dir)
		BTRFS_I(dir)->index_cnt--;
3495 3496
	btrfs_free_path(path);
	return ERR_PTR(ret);
C
Chris Mason 已提交
3497 3498 3499 3500 3501 3502 3503
}

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

C
Chris Mason 已提交
3504 3505 3506 3507 3508 3509
/*
 * 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.
 */
3510 3511 3512
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 已提交
3513 3514 3515
{
	int ret;
	struct btrfs_key key;
3516
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
3517

C
Chris Mason 已提交
3518 3519 3520 3521
	key.objectid = inode->i_ino;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
	key.offset = 0;

3522 3523
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode->i_ino,
3524
				    &key, btrfs_inode_type(inode),
3525
				    index);
C
Chris Mason 已提交
3526
	if (ret == 0) {
3527 3528
		if (add_backref) {
			ret = btrfs_insert_inode_ref(trans, root,
3529 3530 3531 3532
						     name, name_len,
						     inode->i_ino,
						     parent_inode->i_ino,
						     index);
3533
		}
3534
		btrfs_i_size_write(parent_inode, parent_inode->i_size +
3535
				   name_len * 2);
3536
		parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
3537
		ret = btrfs_update_inode(trans, root, parent_inode);
C
Chris Mason 已提交
3538 3539 3540 3541 3542
	}
	return ret;
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
3543
			    struct dentry *dentry, struct inode *inode,
3544
			    int backref, u64 index)
C
Chris Mason 已提交
3545
{
3546 3547 3548
	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 已提交
3549 3550 3551 3552 3553 3554 3555 3556 3557
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
3558 3559 3560 3561 3562
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;
3563
	struct inode *inode = NULL;
J
Josef Bacik 已提交
3564 3565 3566
	int err;
	int drop_inode = 0;
	u64 objectid;
3567
	unsigned long nr = 0;
3568
	u64 index = 0;
J
Josef Bacik 已提交
3569 3570 3571 3572

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

3573 3574 3575 3576
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;

J
Josef Bacik 已提交
3577 3578 3579 3580 3581 3582 3583 3584 3585
	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;
	}

3586
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3587 3588
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3589
				BTRFS_I(dir)->block_group, mode, &index);
J
Josef Bacik 已提交
3590 3591 3592 3593
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Josef Bacik 已提交
3594 3595 3596 3597 3598 3599
	err = btrfs_init_acl(inode, dir);
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

J
Josef Bacik 已提交
3600
	btrfs_set_trans_block_group(trans, inode);
3601
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
J
Josef Bacik 已提交
3602 3603 3604 3605 3606
	if (err)
		drop_inode = 1;
	else {
		inode->i_op = &btrfs_special_inode_operations;
		init_special_inode(inode, inode->i_mode, rdev);
3607
		btrfs_update_inode(trans, root, inode);
J
Josef Bacik 已提交
3608 3609 3610 3611 3612
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3613
	nr = trans->blocks_used;
3614
	btrfs_end_transaction_throttle(trans, root);
3615
fail:
J
Josef Bacik 已提交
3616 3617 3618 3619
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3620
	btrfs_btree_balance_dirty(root, nr);
J
Josef Bacik 已提交
3621 3622 3623
	return err;
}

C
Chris Mason 已提交
3624 3625 3626 3627 3628
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;
3629
	struct inode *inode = NULL;
C
Chris Mason 已提交
3630 3631
	int err;
	int drop_inode = 0;
3632
	unsigned long nr = 0;
C
Chris Mason 已提交
3633
	u64 objectid;
3634
	u64 index = 0;
C
Chris Mason 已提交
3635

3636 3637 3638
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;
C
Chris Mason 已提交
3639 3640 3641 3642 3643 3644 3645 3646 3647
	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;
	}

3648
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3649 3650
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino,
3651 3652
				objectid, BTRFS_I(dir)->block_group, mode,
				&index);
C
Chris Mason 已提交
3653 3654 3655 3656
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Josef Bacik 已提交
3657 3658 3659 3660 3661 3662
	err = btrfs_init_acl(inode, dir);
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
3663
	btrfs_set_trans_block_group(trans, inode);
3664
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
3665 3666 3667 3668
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
3669
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
3670 3671
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
3672
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
3673 3674 3675 3676 3677
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3678
	nr = trans->blocks_used;
3679
	btrfs_end_transaction_throttle(trans, root);
3680
fail:
C
Chris Mason 已提交
3681 3682 3683 3684
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3685
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3686 3687 3688 3689 3690 3691 3692 3693 3694
	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;
3695
	u64 index;
3696
	unsigned long nr = 0;
C
Chris Mason 已提交
3697 3698 3699 3700 3701 3702
	int err;
	int drop_inode = 0;

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

3703
	btrfs_inc_nlink(inode);
3704 3705 3706
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;
3707
	err = btrfs_set_inode_index(dir, &index);
3708 3709 3710
	if (err)
		goto fail;

C
Chris Mason 已提交
3711
	trans = btrfs_start_transaction(root, 1);
3712

C
Chris Mason 已提交
3713 3714
	btrfs_set_trans_block_group(trans, dir);
	atomic_inc(&inode->i_count);
3715

3716
	err = btrfs_add_nondir(trans, dentry, inode, 1, index);
3717

C
Chris Mason 已提交
3718 3719
	if (err)
		drop_inode = 1;
3720

C
Chris Mason 已提交
3721 3722
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, dir);
3723
	err = btrfs_update_inode(trans, root, inode);
3724

3725 3726
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
3727

3728
	nr = trans->blocks_used;
3729
	btrfs_end_transaction_throttle(trans, root);
3730
fail:
C
Chris Mason 已提交
3731 3732 3733 3734
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3735
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3736 3737 3738 3739 3740
	return err;
}

static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
3741
	struct inode *inode = NULL;
C
Chris Mason 已提交
3742 3743 3744 3745
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
3746
	u64 objectid = 0;
3747
	u64 index = 0;
3748
	unsigned long nr = 1;
C
Chris Mason 已提交
3749

3750 3751 3752 3753
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto out_unlock;

C
Chris Mason 已提交
3754 3755
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);
3756

C
Chris Mason 已提交
3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767
	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;
	}

3768
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3769 3770
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3771 3772
				BTRFS_I(dir)->block_group, S_IFDIR | mode,
				&index);
C
Chris Mason 已提交
3773 3774 3775 3776
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
3777

C
Chris Mason 已提交
3778
	drop_on_err = 1;
J
Josef Bacik 已提交
3779 3780 3781 3782 3783

	err = btrfs_init_acl(inode, dir);
	if (err)
		goto out_fail;

C
Chris Mason 已提交
3784 3785 3786 3787
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;
	btrfs_set_trans_block_group(trans, inode);

3788
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
3789 3790 3791
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
3792

3793 3794 3795
	err = btrfs_add_link(trans, dentry->d_parent->d_inode,
				 inode, dentry->d_name.name,
				 dentry->d_name.len, 0, index);
C
Chris Mason 已提交
3796 3797
	if (err)
		goto out_fail;
3798

C
Chris Mason 已提交
3799 3800 3801 3802 3803 3804 3805
	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:
3806
	nr = trans->blocks_used;
3807
	btrfs_end_transaction_throttle(trans, root);
3808

C
Chris Mason 已提交
3809 3810 3811
out_unlock:
	if (drop_on_err)
		iput(inode);
3812
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3813 3814 3815
	return err;
}

C
Chris Mason 已提交
3816 3817 3818 3819
/* 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.
 */
3820 3821
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
3822 3823
				struct extent_map *em,
				u64 map_start, u64 map_len)
3824 3825 3826
{
	u64 start_diff;

3827 3828 3829 3830
	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 已提交
3831 3832
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
3833
		em->block_start += start_diff;
C
Chris Mason 已提交
3834 3835
		em->block_len -= start_diff;
	}
3836
	return add_extent_mapping(em_tree, em);
3837 3838
}

C
Chris Mason 已提交
3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
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);

3860
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
C
Chris Mason 已提交
3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
	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 已提交
3875 3876
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
C
Chris Mason 已提交
3877 3878
 * 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 已提交
3879 3880 3881 3882
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
C
Chris Mason 已提交
3883

3884
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3885
				    size_t pg_offset, u64 start, u64 len,
3886 3887 3888 3889
				    int create)
{
	int ret;
	int err = 0;
3890
	u64 bytenr;
3891 3892 3893 3894
	u64 extent_start = 0;
	u64 extent_end = 0;
	u64 objectid = inode->i_ino;
	u32 found_type;
3895
	struct btrfs_path *path = NULL;
3896 3897
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
3898 3899
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
3900 3901
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
3902
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
3903
	struct btrfs_trans_handle *trans = NULL;
C
Chris Mason 已提交
3904
	int compressed;
3905 3906

again:
3907 3908
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
3909 3910
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
3911 3912
	spin_unlock(&em_tree->lock);

3913
	if (em) {
3914 3915 3916
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
3917 3918 3919
			free_extent_map(em);
		else
			goto out;
3920
	}
3921
	em = alloc_extent_map(GFP_NOFS);
3922
	if (!em) {
3923 3924
		err = -ENOMEM;
		goto out;
3925
	}
3926
	em->bdev = root->fs_info->fs_devices->latest_bdev;
3927
	em->start = EXTENT_MAP_HOLE;
3928
	em->orig_start = EXTENT_MAP_HOLE;
3929
	em->len = (u64)-1;
C
Chris Mason 已提交
3930
	em->block_len = (u64)-1;
3931 3932 3933 3934 3935 3936

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

3937 3938
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

3950 3951
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
3952 3953
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
3954 3955 3956
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
3957 3958 3959 3960
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

3961 3962
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
C
Chris Mason 已提交
3963
	compressed = btrfs_file_extent_compression(leaf, item);
Y
Yan Zheng 已提交
3964 3965
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
3966
		extent_end = extent_start +
3967
		       btrfs_file_extent_num_bytes(leaf, item);
Y
Yan Zheng 已提交
3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981
	} 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;
3982
			}
Y
Yan Zheng 已提交
3983 3984 3985
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
3986
		}
Y
Yan Zheng 已提交
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997
		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 已提交
3998 3999
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
4000 4001
		em->start = extent_start;
		em->len = extent_end - extent_start;
4002 4003
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
4004 4005
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
4006
			em->block_start = EXTENT_MAP_HOLE;
4007 4008
			goto insert;
		}
C
Chris Mason 已提交
4009 4010 4011 4012 4013 4014 4015 4016 4017
		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 已提交
4018 4019
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
C
Chris Mason 已提交
4020
		}
4021 4022
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
4023
		unsigned long ptr;
4024
		char *map;
4025 4026 4027
		size_t size;
		size_t extent_offset;
		size_t copy_size;
4028

4029
		em->block_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4030
		if (!page || create) {
4031
			em->start = extent_start;
Y
Yan Zheng 已提交
4032
			em->len = extent_end - extent_start;
4033 4034
			goto out;
		}
4035

Y
Yan Zheng 已提交
4036 4037
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
4038
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
4039 4040
				size - extent_offset);
		em->start = extent_start + extent_offset;
4041 4042
		em->len = (copy_size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
4043
		em->orig_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4044 4045
		if (compressed)
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
4046
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
4047
		if (create == 0 && !PageUptodate(page)) {
C
Chris Mason 已提交
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059
			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);
			}
4060 4061 4062 4063 4064 4065 4066
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
				btrfs_release_path(root, path);
4067
				trans = btrfs_join_transaction(root, 1);
4068 4069
				goto again;
			}
C
Chris Mason 已提交
4070
			map = kmap(page);
4071
			write_extent_buffer(leaf, map + pg_offset, ptr,
4072
					    copy_size);
C
Chris Mason 已提交
4073
			kunmap(page);
4074
			btrfs_mark_buffer_dirty(leaf);
4075
		}
4076 4077
		set_extent_uptodate(io_tree, em->start,
				    extent_map_end(em) - 1, GFP_NOFS);
4078 4079
		goto insert;
	} else {
C
Chris Mason 已提交
4080
		printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
4081 4082 4083 4084
		WARN_ON(1);
	}
not_found:
	em->start = start;
4085
	em->len = len;
4086
not_found_em:
4087
	em->block_start = EXTENT_MAP_HOLE;
Y
Yan Zheng 已提交
4088
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
4089 4090
insert:
	btrfs_release_path(root, path);
4091
	if (em->start > start || extent_map_end(em) <= start) {
C
Chris Mason 已提交
4092 4093 4094 4095 4096
		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);
4097 4098 4099
		err = -EIO;
		goto out;
	}
4100 4101 4102

	err = 0;
	spin_lock(&em_tree->lock);
4103
	ret = add_extent_mapping(em_tree, em);
4104 4105 4106 4107
	/* 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
	 */
4108
	if (ret == -EEXIST) {
4109
		struct extent_map *existing;
4110 4111 4112

		ret = 0;

4113
		existing = lookup_extent_mapping(em_tree, start, len);
4114 4115 4116 4117 4118
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
4119 4120 4121 4122 4123
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
4124 4125
							   em, start,
							   root->sectorsize);
4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138
				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;
4139
			err = 0;
4140 4141
		}
	}
4142
	spin_unlock(&em_tree->lock);
4143
out:
4144 4145
	if (path)
		btrfs_free_path(path);
4146 4147
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
4148
		if (!err)
4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		WARN_ON(1);
		return ERR_PTR(err);
	}
	return em;
}

4159 4160 4161 4162
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
4163
	return -EINVAL;
4164 4165
}

4166
static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
C
Chris Mason 已提交
4167
{
4168
	return extent_bmap(mapping, iblock, btrfs_get_extent);
C
Chris Mason 已提交
4169 4170
}

4171
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
4172
{
4173 4174
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4175
	return extent_read_full_page(tree, page, btrfs_get_extent);
C
Chris Mason 已提交
4176
}
4177

4178
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
4179
{
4180
	struct extent_io_tree *tree;
4181 4182 4183 4184 4185 4186 4187


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

4192 4193
int btrfs_writepages(struct address_space *mapping,
		     struct writeback_control *wbc)
C
Chris Mason 已提交
4194
{
4195
	struct extent_io_tree *tree;
4196

4197
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4198 4199 4200
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
4201 4202 4203 4204
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
4205 4206
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4207 4208 4209
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
4210
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
C
Chris Mason 已提交
4211
{
4212 4213
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
4214
	int ret;
4215

4216 4217
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
4218
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
4219 4220 4221 4222
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
4223
	}
4224
	return ret;
C
Chris Mason 已提交
4225 4226
}

4227 4228
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
4229 4230
	if (PageWriteback(page) || PageDirty(page))
		return 0;
4231 4232 4233
	return __btrfs_releasepage(page, gfp_flags);
}

4234
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
4235
{
4236
	struct extent_io_tree *tree;
4237 4238 4239
	struct btrfs_ordered_extent *ordered;
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
4240

4241
	wait_on_page_writeback(page);
4242
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4243 4244 4245 4246 4247 4248 4249 4250 4251
	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) {
4252 4253 4254 4255
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
4256 4257 4258
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
				 EXTENT_LOCKED, 1, 0, GFP_NOFS);
4259 4260
		btrfs_finish_ordered_io(page->mapping->host,
					page_start, page_end);
4261 4262 4263 4264 4265 4266 4267 4268 4269
		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 已提交
4270
	ClearPageChecked(page);
4271 4272 4273 4274 4275
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
4276 4277
}

C
Chris Mason 已提交
4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294
/*
 * 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.
 */
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
{
4295
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
4296
	struct btrfs_root *root = BTRFS_I(inode)->root;
4297 4298 4299 4300
	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 已提交
4301
	loff_t size;
4302
	int ret;
4303
	u64 page_start;
4304
	u64 page_end;
C
Chris Mason 已提交
4305

4306 4307 4308 4309 4310
	ret = btrfs_check_free_space(root, PAGE_CACHE_SIZE, 0);
	if (ret)
		goto out;

	ret = -EINVAL;
4311
again:
C
Chris Mason 已提交
4312 4313
	lock_page(page);
	size = i_size_read(inode);
4314 4315
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
4316

C
Chris Mason 已提交
4317
	if ((page->mapping != inode->i_mapping) ||
4318
	    (page_start >= size)) {
C
Chris Mason 已提交
4319 4320 4321
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
4322 4323 4324 4325 4326
	wait_on_page_writeback(page);

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

4327 4328 4329 4330
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
4331 4332 4333 4334
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
		unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
		unlock_page(page);
4335
		btrfs_start_ordered_extent(inode, ordered, 1);
4336 4337 4338 4339
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

4340
	btrfs_set_extent_delalloc(inode, page_start, page_end);
4341
	ret = 0;
C
Chris Mason 已提交
4342 4343

	/* page is wholly or partially inside EOF */
4344
	if (page_start + PAGE_CACHE_SIZE > size)
4345
		zero_start = size & ~PAGE_CACHE_MASK;
C
Chris Mason 已提交
4346
	else
4347
		zero_start = PAGE_CACHE_SIZE;
C
Chris Mason 已提交
4348

4349 4350 4351 4352 4353 4354
	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);
	}
4355
	ClearPageChecked(page);
4356 4357
	set_page_dirty(page);
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
4358 4359 4360

out_unlock:
	unlock_page(page);
4361
out:
C
Chris Mason 已提交
4362 4363 4364
	return ret;
}

C
Chris Mason 已提交
4365 4366 4367 4368 4369
static void btrfs_truncate(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;
	struct btrfs_trans_handle *trans;
4370
	unsigned long nr;
4371
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
4372 4373 4374 4375 4376 4377 4378

	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 已提交
4379
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
C
Chris Mason 已提交
4380 4381 4382

	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
4383
	btrfs_i_size_write(inode, inode->i_size);
C
Chris Mason 已提交
4384

4385 4386 4387
	ret = btrfs_orphan_add(trans, inode);
	if (ret)
		goto out;
C
Chris Mason 已提交
4388
	/* FIXME, add redo link to tree so we don't leak on crash */
4389
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size,
4390
				      BTRFS_EXTENT_DATA_KEY);
C
Chris Mason 已提交
4391
	btrfs_update_inode(trans, root, inode);
4392

4393 4394 4395 4396 4397
	ret = btrfs_orphan_del(trans, inode);
	BUG_ON(ret);

out:
	nr = trans->blocks_used;
4398
	ret = btrfs_end_transaction_throttle(trans, root);
C
Chris Mason 已提交
4399
	BUG_ON(ret);
4400
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4401 4402
}

C
Chris Mason 已提交
4403 4404 4405
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
4406 4407 4408
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 已提交
4409 4410
{
	struct inode *inode;
4411
	int error;
4412
	u64 index = 0;
C
Chris Mason 已提交
4413

4414
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid,
4415
				new_dirid, alloc_hint, S_IFDIR | 0700, &index);
4416
	if (IS_ERR(inode))
C
Christoph Hellwig 已提交
4417
		return PTR_ERR(inode);
C
Chris Mason 已提交
4418 4419 4420 4421
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

	inode->i_nlink = 1;
4422
	btrfs_i_size_write(inode, 0);
4423

4424 4425 4426 4427 4428 4429
	error = btrfs_update_inode(trans, new_root, inode);
	if (error)
		return error;

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

C
Chris Mason 已提交
4432 4433 4434
/* helper function for file defrag and space balancing.  This
 * forces readahead on a given range of bytes in an inode
 */
4435
unsigned long btrfs_force_ra(struct address_space *mapping,
4436 4437 4438
			      struct file_ra_state *ra, struct file *file,
			      pgoff_t offset, pgoff_t last_index)
{
4439
	pgoff_t req_size = last_index - offset + 1;
4440 4441 4442 4443 4444

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

C
Chris Mason 已提交
4445 4446 4447 4448 4449 4450 4451
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;
4452
	ei->last_trans = 0;
4453
	ei->logged_trans = 0;
4454
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
J
Josef Bacik 已提交
4455 4456
	ei->i_acl = BTRFS_ACL_NOT_CACHED;
	ei->i_default_acl = BTRFS_ACL_NOT_CACHED;
4457
	INIT_LIST_HEAD(&ei->i_orphan);
C
Chris Mason 已提交
4458 4459 4460 4461 4462
	return &ei->vfs_inode;
}

void btrfs_destroy_inode(struct inode *inode)
{
4463
	struct btrfs_ordered_extent *ordered;
C
Chris Mason 已提交
4464 4465 4466
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);

J
Josef Bacik 已提交
4467 4468 4469 4470 4471 4472 4473
	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);

4474
	spin_lock(&BTRFS_I(inode)->root->list_lock);
4475 4476 4477 4478 4479
	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();
	}
4480
	spin_unlock(&BTRFS_I(inode)->root->list_lock);
4481

C
Chris Mason 已提交
4482
	while (1) {
4483 4484 4485 4486
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
C
Chris Mason 已提交
4487 4488 4489 4490
			printk(KERN_ERR "btrfs found ordered "
			       "extent %llu %llu on inode cleanup\n",
			       (unsigned long long)ordered->file_offset,
			       (unsigned long long)ordered->len);
4491 4492 4493 4494 4495
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
4496
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
C
Chris Mason 已提交
4497 4498 4499
	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

4500
static void init_once(void *foo)
C
Chris Mason 已提交
4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520
{
	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);
}

4521
struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
4522
				       unsigned long extra_flags,
4523
				       void (*ctor)(void *))
4524 4525
{
	return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
4526
				 SLAB_MEM_SPREAD | extra_flags), ctor);
4527 4528
}

C
Chris Mason 已提交
4529 4530
int btrfs_init_cachep(void)
{
4531
	btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
4532 4533
					  sizeof(struct btrfs_inode),
					  0, init_once);
C
Chris Mason 已提交
4534 4535
	if (!btrfs_inode_cachep)
		goto fail;
4536 4537 4538 4539
	btrfs_trans_handle_cachep =
			btrfs_cache_create("btrfs_trans_handle_cache",
					   sizeof(struct btrfs_trans_handle),
					   0, NULL);
C
Chris Mason 已提交
4540 4541
	if (!btrfs_trans_handle_cachep)
		goto fail;
4542
	btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
C
Chris Mason 已提交
4543
					     sizeof(struct btrfs_transaction),
4544
					     0, NULL);
C
Chris Mason 已提交
4545 4546
	if (!btrfs_transaction_cachep)
		goto fail;
4547
	btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
4548
					 sizeof(struct btrfs_path),
4549
					 0, NULL);
C
Chris Mason 已提交
4550 4551
	if (!btrfs_path_cachep)
		goto fail;
4552
	btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
4553
					      SLAB_DESTROY_BY_RCU, NULL);
C
Chris Mason 已提交
4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566
	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);
4567
	stat->dev = BTRFS_I(inode)->root->anon_super.s_dev;
C
Chris Mason 已提交
4568
	stat->blksize = PAGE_CACHE_SIZE;
4569 4570
	stat->blocks = (inode_get_bytes(inode) +
			BTRFS_I(inode)->delalloc_bytes) >> 9;
C
Chris Mason 已提交
4571 4572 4573
	return 0;
}

C
Chris Mason 已提交
4574 4575
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
4576 4577 4578 4579 4580 4581
{
	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;
4582
	u64 index = 0;
C
Chris Mason 已提交
4583 4584
	int ret;

4585 4586 4587 4588 4589
	/* 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 已提交
4590 4591 4592 4593
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
		return -ENOTEMPTY;
	}
4594

4595 4596 4597 4598 4599 4600
	/* 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;

4601 4602 4603 4604
	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto out_unlock;

C
Chris Mason 已提交
4605
	trans = btrfs_start_transaction(root, 1);
4606

C
Chris Mason 已提交
4607 4608
	btrfs_set_trans_block_group(trans, new_dir);

4609
	btrfs_inc_nlink(old_dentry->d_inode);
C
Chris Mason 已提交
4610 4611 4612
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
4613

4614 4615 4616
	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 已提交
4617 4618 4619 4620 4621
	if (ret)
		goto out_fail;

	if (new_inode) {
		new_inode->i_ctime = CURRENT_TIME;
4622 4623 4624 4625
		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 已提交
4626 4627
		if (ret)
			goto out_fail;
4628
		if (new_inode->i_nlink == 0) {
4629
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
4630 4631 4632
			if (ret)
				goto out_fail;
		}
4633

C
Chris Mason 已提交
4634
	}
4635
	ret = btrfs_set_inode_index(new_dir, &index);
4636 4637 4638
	if (ret)
		goto out_fail;

4639 4640 4641
	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 已提交
4642 4643 4644 4645
	if (ret)
		goto out_fail;

out_fail:
4646
	btrfs_end_transaction_throttle(trans, root);
4647
out_unlock:
C
Chris Mason 已提交
4648 4649 4650
	return ret;
}

C
Chris Mason 已提交
4651 4652 4653 4654
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
4655 4656 4657 4658
int btrfs_start_delalloc_inodes(struct btrfs_root *root)
{
	struct list_head *head = &root->fs_info->delalloc_inodes;
	struct btrfs_inode *binode;
4659
	struct inode *inode;
4660

Y
Yan Zheng 已提交
4661 4662 4663
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

4664
	spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
4665
	while (!list_empty(head)) {
4666 4667
		binode = list_entry(head->next, struct btrfs_inode,
				    delalloc_inodes);
4668 4669 4670
		inode = igrab(&binode->vfs_inode);
		if (!inode)
			list_del_init(&binode->delalloc_inodes);
4671
		spin_unlock(&root->fs_info->delalloc_lock);
4672
		if (inode) {
4673
			filemap_flush(inode->i_mapping);
4674 4675 4676
			iput(inode);
		}
		cond_resched();
4677
		spin_lock(&root->fs_info->delalloc_lock);
4678
	}
4679
	spin_unlock(&root->fs_info->delalloc_lock);
4680 4681 4682 4683 4684 4685

	/* 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 已提交
4686
	while (atomic_read(&root->fs_info->nr_async_submits) ||
4687
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
4688
		wait_event(root->fs_info->async_submit_wait,
4689 4690
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
4691 4692
	}
	atomic_dec(&root->fs_info->async_submit_draining);
4693 4694 4695
	return 0;
}

C
Chris Mason 已提交
4696 4697 4698 4699 4700 4701 4702
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;
4703
	struct inode *inode = NULL;
C
Chris Mason 已提交
4704 4705 4706
	int err;
	int drop_inode = 0;
	u64 objectid;
4707
	u64 index = 0 ;
C
Chris Mason 已提交
4708 4709
	int name_len;
	int datasize;
4710
	unsigned long ptr;
C
Chris Mason 已提交
4711
	struct btrfs_file_extent_item *ei;
4712
	struct extent_buffer *leaf;
4713
	unsigned long nr = 0;
C
Chris Mason 已提交
4714 4715 4716 4717

	name_len = strlen(symname) + 1;
	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
		return -ENAMETOOLONG;
4718 4719 4720 4721 4722

	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto out_fail;

C
Chris Mason 已提交
4723 4724 4725 4726 4727 4728 4729 4730 4731
	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;
	}

4732
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4733 4734
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
4735 4736
				BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
				&index);
C
Chris Mason 已提交
4737 4738 4739 4740
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Josef Bacik 已提交
4741 4742 4743 4744 4745 4746
	err = btrfs_init_acl(inode, dir);
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
4747
	btrfs_set_trans_block_group(trans, inode);
4748
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
4749 4750 4751 4752
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
4753
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
4754 4755
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
4756
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
	}
	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);
4772 4773 4774 4775
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}
4776 4777 4778 4779 4780
	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 已提交
4781
				   BTRFS_FILE_EXTENT_INLINE);
C
Chris Mason 已提交
4782 4783 4784 4785 4786
	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 已提交
4787
	ptr = btrfs_file_extent_inline_start(ei);
4788 4789
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
4790
	btrfs_free_path(path);
4791

C
Chris Mason 已提交
4792 4793
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
4794
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
Y
Yan Zheng 已提交
4795
	inode_set_bytes(inode, name_len);
4796
	btrfs_i_size_write(inode, name_len - 1);
4797 4798 4799
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
4800 4801

out_unlock:
4802
	nr = trans->blocks_used;
4803
	btrfs_end_transaction_throttle(trans, root);
4804
out_fail:
C
Chris Mason 已提交
4805 4806 4807 4808
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
4809
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4810 4811
	return err;
}
4812

Y
Yan Zheng 已提交
4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
static int prealloc_file_range(struct inode *inode, u64 start, u64 end,
			       u64 alloc_hint, int mode)
{
	struct btrfs_trans_handle *trans;
	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;

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

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

	btrfs_end_transaction(trans, root);
	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;
	int ret;

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

	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;
		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);
			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) {
			ret = prealloc_file_range(inode, cur_offset,
					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);
out:
	mutex_unlock(&inode->i_mutex);
	return ret;
}

4937 4938 4939 4940 4941
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

4942
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
4943 4944 4945
{
	if (btrfs_test_flag(inode, READONLY) && (mask & MAY_WRITE))
		return -EACCES;
J
Josef Bacik 已提交
4946
	return generic_permission(inode, mask, btrfs_check_acl);
Y
Yan 已提交
4947
}
C
Chris Mason 已提交
4948 4949

static struct inode_operations btrfs_dir_inode_operations = {
4950
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
4951 4952 4953 4954 4955 4956 4957 4958 4959
	.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 已提交
4960
	.mknod		= btrfs_mknod,
4961 4962
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
4963
	.listxattr	= btrfs_listxattr,
4964
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
4965
	.permission	= btrfs_permission,
C
Chris Mason 已提交
4966 4967 4968
};
static struct inode_operations btrfs_dir_ro_inode_operations = {
	.lookup		= btrfs_lookup,
Y
Yan 已提交
4969
	.permission	= btrfs_permission,
C
Chris Mason 已提交
4970 4971 4972 4973
};
static struct file_operations btrfs_dir_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
4974
	.readdir	= btrfs_real_readdir,
C
Christoph Hellwig 已提交
4975
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
4976
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
4977
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
4978
#endif
S
Sage Weil 已提交
4979
	.release        = btrfs_release_file,
4980
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
4981 4982
};

4983
static struct extent_io_ops btrfs_extent_io_ops = {
4984
	.fill_delalloc = run_delalloc_range,
4985
	.submit_bio_hook = btrfs_submit_bio_hook,
4986
	.merge_bio_hook = btrfs_merge_bio_hook,
4987
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
4988
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
4989
	.writepage_start_hook = btrfs_writepage_start_hook,
4990
	.readpage_io_failed_hook = btrfs_io_failed_hook,
C
Chris Mason 已提交
4991 4992
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
4993 4994
};

C
Chris Mason 已提交
4995 4996 4997
static struct address_space_operations btrfs_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
4998
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
4999
	.readpages	= btrfs_readpages,
C
Chris Mason 已提交
5000 5001
	.sync_page	= block_sync_page,
	.bmap		= btrfs_bmap,
5002
	.direct_IO	= btrfs_direct_IO,
5003 5004
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
5005
	.set_page_dirty	= btrfs_set_page_dirty,
C
Chris Mason 已提交
5006 5007 5008 5009 5010
};

static struct address_space_operations btrfs_symlink_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
5011 5012
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
5013 5014 5015 5016 5017 5018
};

static struct inode_operations btrfs_file_inode_operations = {
	.truncate	= btrfs_truncate,
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
5019 5020
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5021
	.listxattr      = btrfs_listxattr,
5022
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
5023
	.permission	= btrfs_permission,
Y
Yan Zheng 已提交
5024
	.fallocate	= btrfs_fallocate,
C
Chris Mason 已提交
5025
};
J
Josef Bacik 已提交
5026 5027 5028
static struct inode_operations btrfs_special_inode_operations = {
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
5029
	.permission	= btrfs_permission,
5030 5031
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5032
	.listxattr	= btrfs_listxattr,
5033
	.removexattr	= btrfs_removexattr,
J
Josef Bacik 已提交
5034
};
C
Chris Mason 已提交
5035 5036 5037 5038
static struct inode_operations btrfs_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
Y
Yan 已提交
5039
	.permission	= btrfs_permission,
C
Chris Mason 已提交
5040
};