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

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 已提交
62
static struct inode_operations btrfs_special_inode_operations;
C
Chris Mason 已提交
63 64 65 66
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;
67
static struct extent_io_ops btrfs_extent_io_ops;
C
Chris Mason 已提交
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

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

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

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

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

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

C
Chris Mason 已提交
102 103 104 105 106
/*
 * 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 已提交
107
static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
				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 已提交
131 132
	path = btrfs_alloc_path();
	if (!path)
C
Chris Mason 已提交
133 134
		return -ENOMEM;

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

	key.objectid = inode->i_ino;
	key.offset = start;
	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
	datasize = btrfs_file_extent_calc_inline_size(cur_size);

	inode_add_bytes(inode, size);
	ret = btrfs_insert_empty_item(trans, root, path, &key,
				      datasize);
	BUG_ON(ret);
	if (ret) {
		err = ret;
		goto fail;
	}
	leaf = path->nodes[0];
	ei = btrfs_item_ptr(leaf, path->slots[0],
			    struct btrfs_file_extent_item);
	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
	btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
	btrfs_set_file_extent_encryption(leaf, ei, 0);
	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
	btrfs_set_file_extent_ram_bytes(leaf, ei, size);
	ptr = btrfs_file_extent_inline_start(ei);

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

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

			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.
 */
206
static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
				 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 已提交
225
	    actual_end >= PAGE_CACHE_SIZE ||
C
Chris Mason 已提交
226 227 228 229 230 231 232 233 234
	    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,
235
				 aligned_end, aligned_end, start, &hint_byte);
C
Chris Mason 已提交
236 237 238 239 240 241 242 243 244 245 246 247
	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;
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
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 已提交
285
/*
286 287 288
 * 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 已提交
289
 *
290 291 292 293 294
 * 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 已提交
295
 *
296 297 298 299
 * 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 已提交
300
 */
301 302 303 304 305
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)
306 307 308
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
309
	u64 num_bytes;
C
Chris Mason 已提交
310 311
	u64 orig_start;
	u64 disk_num_bytes;
312
	u64 blocksize = root->sectorsize;
C
Chris Mason 已提交
313
	u64 actual_end;
314
	u64 isize = i_size_read(inode);
315
	int ret = 0;
C
Chris Mason 已提交
316 317 318 319 320 321
	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;
322
	unsigned long max_uncompressed = 128 * 1024;
C
Chris Mason 已提交
323 324
	int i;
	int will_compress;
325

C
Chris Mason 已提交
326 327
	orig_start = start;

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

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

C
Chris Mason 已提交
347 348 349 350
	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
351 352 353 354 355 356 357
	 * 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 已提交
358 359
	 */
	total_compressed = min(total_compressed, max_uncompressed);
360
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
361
	num_bytes = max(blocksize,  num_bytes);
C
Chris Mason 已提交
362 363 364
	disk_num_bytes = num_bytes;
	total_in = 0;
	ret = 0;
365

366 367 368 369
	/*
	 * 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 已提交
370
	 */
371
	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
C
Chris Mason 已提交
372 373
	    btrfs_test_opt(root, COMPRESS)) {
		WARN_ON(pages);
374
		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
C
Chris Mason 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401

		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) {
402 403 404 405
		trans = btrfs_join_transaction(root, 1);
		BUG_ON(!trans);
		btrfs_set_trans_block_group(trans, inode);

C
Chris Mason 已提交
406
		/* lets try to make an inline extent */
407
		if (ret || total_in < (actual_end - start)) {
C
Chris Mason 已提交
408
			/* we didn't compress the entire range, try
409
			 * to make an uncompressed inline extent.
C
Chris Mason 已提交
410 411 412 413
			 */
			ret = cow_file_range_inline(trans, root, inode,
						    start, end, 0, NULL);
		} else {
414
			/* try making a compressed inline extent */
C
Chris Mason 已提交
415 416 417 418
			ret = cow_file_range_inline(trans, root, inode,
						    start, end,
						    total_compressed, pages);
		}
419
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
420
		if (ret == 0) {
421 422 423 424 425
			/*
			 * 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 已提交
426 427
			extent_clear_unlock_delalloc(inode,
						     &BTRFS_I(inode)->io_tree,
428 429
						     start, end, NULL, 1, 0,
						     0, 1, 1, 1);
C
Chris Mason 已提交
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
			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 已提交
463
			WARN_ON(pages[i]->mapping);
C
Chris Mason 已提交
464 465 466 467 468 469 470 471
			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 */
472
		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
C
Chris Mason 已提交
473
	}
474 475
	if (will_compress) {
		*num_added += 1;
C
Chris Mason 已提交
476

477 478 479 480 481 482
		/* 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);
483

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

508 509 510 511 512 513 514 515
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 已提交
516
	kfree(pages);
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544

	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 已提交
545
	while (!list_empty(&async_cow->extents)) {
546 547 548
		async_extent = list_entry(async_cow->extents.next,
					  struct async_extent, list);
		list_del(&async_extent->list);
C
Chris Mason 已提交
549

550 551 552 553 554 555 556 557
		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 已提交
558 559
				    async_extent->start +
				    async_extent->ram_size - 1, GFP_NOFS);
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576

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

608 609 610 611 612 613
		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 已提交
614
		while (1) {
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
			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 已提交
647 648 649 650 651
				    async_extent->start,
				    async_extent->ram_size,
				    ins.objectid,
				    ins.offset, async_extent->pages,
				    async_extent->nr_pages);
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691

		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;
692
	u64 isize = i_size_read(inode);
693 694 695 696 697 698 699 700 701
	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);

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

	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 已提交
731
	while (disk_num_bytes > 0) {
C
Chris Mason 已提交
732
		cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
733
		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
734
					   root->sectorsize, 0, alloc_hint,
735
					   (u64)-1, &ins, 1);
C
Chris Mason 已提交
736 737
		BUG_ON(ret);

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

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

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

C
Chris Mason 已提交
750
		while (1) {
751 752 753 754 755 756 757 758
			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 已提交
759
						start + ram_size - 1, 0);
760 761
		}

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

767 768 769 770 771 772 773
		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 已提交
774
		if (disk_num_bytes < cur_alloc_size)
775
			break;
C
Chris Mason 已提交
776

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

794
	return ret;
795
}
C
Chris Mason 已提交
796

797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
/*
 * 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 已提交
835
	if (async_cow->inode)
836 837
		submit_compressed_extents(async_cow->inode, async_cow);
}
C
Chris Mason 已提交
838

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
static noinline void async_cow_free(struct btrfs_work *work)
{
	struct async_cow *async_cow;
	async_cow = container_of(work, struct async_cow, work);
	kfree(async_cow);
}

static int cow_file_range_async(struct inode *inode, struct page *locked_page,
				u64 start, u64 end, int *page_started,
				unsigned long *nr_written)
{
	struct async_cow *async_cow;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	unsigned long nr_pages;
	u64 cur_end;
	int limit = 10 * 1024 * 1042;

	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED |
			 EXTENT_DELALLOC, 1, 0, GFP_NOFS);
C
Chris Mason 已提交
858
	while (start < end) {
859 860 861 862 863 864
		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;

865
		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
			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 已提交
891
		while (atomic_read(&root->fs_info->async_submit_draining) &&
892 893 894 895 896 897 898 899 900 901 902
		      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;
903 904
}

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

Y
Yan Zheng 已提交
912 913
	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
				       bytenr + num_bytes - 1, &list);
914 915 916 917 918 919 920 921 922 923 924
	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 已提交
925 926 927 928 929 930 931
/*
 * 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
 */
932 933
static noinline int run_delalloc_nocow(struct inode *inode,
				       struct page *locked_page,
934 935
			      u64 start, u64 end, int *page_started, int force,
			      unsigned long *nr_written)
936 937
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
938
	struct btrfs_trans_handle *trans;
939 940
	struct extent_buffer *leaf;
	struct btrfs_path *path;
Y
Yan Zheng 已提交
941
	struct btrfs_file_extent_item *fi;
942
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
943 944 945
	u64 cow_start;
	u64 cur_offset;
	u64 extent_end;
946
	u64 extent_offset;
Y
Yan Zheng 已提交
947 948 949 950
	u64 disk_bytenr;
	u64 num_bytes;
	int extent_type;
	int ret;
Y
Yan Zheng 已提交
951
	int type;
Y
Yan Zheng 已提交
952 953
	int nocow;
	int check_prev = 1;
954 955 956

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

Y
Yan Zheng 已提交
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
	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];
		}
985

Y
Yan Zheng 已提交
986 987
		nocow = 0;
		disk_bytenr = 0;
988
		num_bytes = 0;
Y
Yan Zheng 已提交
989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
		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 已提交
1005 1006
		if (extent_type == BTRFS_FILE_EXTENT_REG ||
		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
1007
			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1008
			extent_offset = btrfs_file_extent_offset(leaf, fi);
Y
Yan Zheng 已提交
1009 1010 1011 1012 1013 1014
			extent_end = found_key.offset +
				btrfs_file_extent_num_bytes(leaf, fi);
			if (extent_end <= start) {
				path->slots[0]++;
				goto next_slot;
			}
1015 1016
			if (disk_bytenr == 0)
				goto out_check;
Y
Yan Zheng 已提交
1017 1018 1019 1020
			if (btrfs_file_extent_compression(leaf, fi) ||
			    btrfs_file_extent_encryption(leaf, fi) ||
			    btrfs_file_extent_other_encoding(leaf, fi))
				goto out_check;
Y
Yan Zheng 已提交
1021 1022
			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
				goto out_check;
1023
			if (btrfs_extent_readonly(root, disk_bytenr))
Y
Yan Zheng 已提交
1024
				goto out_check;
1025
			if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
1026 1027
						  found_key.offset -
						  extent_offset, disk_bytenr))
1028
				goto out_check;
1029
			disk_bytenr += extent_offset;
1030 1031 1032 1033 1034 1035 1036 1037 1038
			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 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
			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;
1060 1061 1062
		}

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

Y
Yan Zheng 已提交
1071 1072 1073 1074 1075 1076
		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;
1077
			em->orig_start = em->start;
Y
Yan Zheng 已提交
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
			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 已提交
1098 1099

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

Y
Yan Zheng 已提交
1103 1104
		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
					cur_offset, cur_offset + num_bytes - 1,
1105
					locked_page, 1, 1, 1, 0, 0, 0);
Y
Yan Zheng 已提交
1106 1107 1108
		cur_offset = extent_end;
		if (cur_offset > end)
			break;
1109
	}
Y
Yan Zheng 已提交
1110 1111 1112 1113 1114 1115
	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,
1116
				     page_started, nr_written, 1);
Y
Yan Zheng 已提交
1117 1118 1119 1120 1121
		BUG_ON(ret);
	}

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

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

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

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

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

1193
		spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
1194
		if (end - start + 1 > root->fs_info->delalloc_bytes) {
C
Chris Mason 已提交
1195 1196 1197 1198 1199
			printk(KERN_INFO "btrfs warning: delalloc account "
			       "%llu %llu\n",
			       (unsigned long long)end - start + 1,
			       (unsigned long long)
			       root->fs_info->delalloc_bytes);
J
Josef Bacik 已提交
1200
			btrfs_delalloc_free_space(root, inode, (u64)-1);
C
Chris Mason 已提交
1201
			root->fs_info->delalloc_bytes = 0;
C
Chris Mason 已提交
1202
			BTRFS_I(inode)->delalloc_bytes = 0;
C
Chris Mason 已提交
1203
		} else {
J
Josef Bacik 已提交
1204 1205
			btrfs_delalloc_free_space(root, inode,
						  end - start + 1);
C
Chris Mason 已提交
1206
			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
	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1294

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
			     struct inode *inode, u64 file_offset,
			     struct list_head *list)
{
	struct btrfs_ordered_sum *sum;

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

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

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

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

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

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

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

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

1431 1432 1433 1434 1435 1436 1437 1438
	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 已提交
1439 1440 1441 1442
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,
1443
				       u64 locked_end,
Y
Yan Zheng 已提交
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
				       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);

1458
	path->leave_spinning = 1;
Y
Yan Zheng 已提交
1459
	ret = btrfs_drop_extents(trans, root, inode, file_pos,
1460 1461
				 file_pos + num_bytes, locked_end,
				 file_pos, &hint);
Y
Yan Zheng 已提交
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
	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);
1482 1483 1484 1485

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

Y
Yan Zheng 已提交
1486 1487 1488 1489 1490 1491 1492 1493
	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;
1494 1495 1496
	ret = btrfs_alloc_reserved_file_extent(trans, root,
					root->root_key.objectid,
					inode->i_ino, file_pos, &ins);
Y
Yan Zheng 已提交
1497 1498
	BUG_ON(ret);
	btrfs_free_path(path);
1499

Y
Yan Zheng 已提交
1500 1501 1502
	return 0;
}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
/*
 * helper function for btrfs_finish_ordered_io, this
 * just reads in some of the csum leaves to prime them into ram
 * before we start the transaction.  It limits the amount of btree
 * reads required while inside the transaction.
 */
static noinline void reada_csum(struct btrfs_root *root,
				struct btrfs_path *path,
				struct btrfs_ordered_extent *ordered_extent)
{
	struct btrfs_ordered_sum *sum;
	u64 bytenr;

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

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

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

	ret = btrfs_dec_test_ordered_pending(inode, start, end - start + 1);
1542
	if (!ret)
1543 1544
		return 0;

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

1568
	trans = btrfs_join_transaction(root, 1);
1569

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

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

C
Chris Mason 已提交
1580
	if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
Y
Yan Zheng 已提交
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
		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,
1596 1597
						ordered_extent->file_offset +
						ordered_extent->len,
Y
Yan Zheng 已提交
1598 1599 1600 1601
						compressed, 0, 0,
						BTRFS_FILE_EXTENT_REG);
		BUG_ON(ret);
	}
1602 1603 1604
	unlock_extent(io_tree, ordered_extent->file_offset,
		    ordered_extent->file_offset + ordered_extent->len - 1,
		    GFP_NOFS);
1605
nocow:
1606 1607 1608
	add_pending_csums(trans, inode, ordered_extent->file_offset,
			  &ordered_extent->list);

1609
	mutex_lock(&BTRFS_I(inode)->extent_mutex);
1610
	btrfs_ordered_update_i_size(inode, ordered_extent);
1611
	btrfs_update_inode(trans, root, inode);
1612
	btrfs_remove_ordered_extent(inode, ordered_extent);
1613
	mutex_unlock(&BTRFS_I(inode)->extent_mutex);
1614

1615 1616 1617 1618 1619 1620 1621 1622 1623
	/* 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;
}

1624
static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
1625 1626 1627 1628 1629
				struct extent_state *state, int uptodate)
{
	return btrfs_finish_ordered_io(page->mapping->host, start, end);
}

C
Chris Mason 已提交
1630 1631 1632 1633 1634 1635 1636 1637
/*
 * 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.
 */
1638 1639 1640 1641 1642
struct io_failure_record {
	struct page *page;
	u64 start;
	u64 len;
	u64 logical;
1643
	unsigned long bio_flags;
1644 1645 1646
	int last_mirror;
};

1647
static int btrfs_io_failed_hook(struct bio *failed_bio,
1648 1649
			 struct page *page, u64 start, u64 end,
			 struct extent_state *state)
1650 1651 1652 1653 1654 1655
{
	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;
1656
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1657 1658 1659
	struct bio *bio;
	int num_copies;
	int ret;
1660
	int rw;
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
	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;
1671
		failrec->bio_flags = 0;
1672

1673 1674 1675 1676 1677 1678 1679
		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);
1680 1681 1682 1683 1684 1685 1686

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

1728
	bio_add_page(bio, page, failrec->len, start - page_offset(page));
1729 1730 1731 1732 1733 1734
	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 已提交
1735
						      failrec->last_mirror,
1736
						      failrec->bio_flags);
1737 1738 1739
	return 0;
}

C
Chris Mason 已提交
1740 1741 1742 1743
/*
 * 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
 */
1744
static int btrfs_clean_io_failures(struct inode *inode, u64 start)
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
{
	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);
		}
	}
1769 1770 1771
	return 0;
}

C
Chris Mason 已提交
1772 1773 1774 1775 1776
/*
 * 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
 */
1777
static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
1778
			       struct extent_state *state)
1779
{
1780
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
1781
	struct inode *inode = page->mapping->host;
1782
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1783
	char *kaddr;
1784
	u64 private = ~(u32)0;
1785
	int ret;
1786 1787
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
1788

1789 1790 1791 1792
	if (PageChecked(page)) {
		ClearPageChecked(page);
		goto good;
	}
1793 1794

	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
1795 1796 1797 1798 1799 1800
		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);
1801
		return 0;
1802
	}
1803

Y
Yan 已提交
1804
	if (state && state->start == start) {
1805 1806 1807 1808 1809
		private = state->private;
		ret = 0;
	} else {
		ret = get_state_private(io_tree, start, &private);
	}
1810
	kaddr = kmap_atomic(page, KM_USER0);
C
Chris Mason 已提交
1811
	if (ret)
1812
		goto zeroit;
C
Chris Mason 已提交
1813

1814 1815
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
C
Chris Mason 已提交
1816
	if (csum != private)
1817
		goto zeroit;
C
Chris Mason 已提交
1818

1819
	kunmap_atomic(kaddr, KM_USER0);
1820
good:
1821 1822 1823
	/* if the io failure tree for this inode is non-empty,
	 * check to see if we've recovered from a failed IO
	 */
1824
	btrfs_clean_io_failures(inode, start);
1825 1826 1827
	return 0;

zeroit:
C
Chris Mason 已提交
1828 1829 1830 1831 1832 1833
	if (printk_ratelimit()) {
		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);
	}
1834 1835
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
1836
	kunmap_atomic(kaddr, KM_USER0);
1837 1838
	if (private == 0)
		return 0;
1839
	return -EIO;
1840
}
1841

1842 1843 1844 1845 1846 1847 1848 1849 1850
/*
 * 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;

1851
	spin_lock(&root->list_lock);
1852 1853 1854

	/* already on the orphan list, we're good */
	if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
1855
		spin_unlock(&root->list_lock);
1856 1857 1858 1859 1860
		return 0;
	}

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

1861
	spin_unlock(&root->list_lock);
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879

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

1880
	spin_lock(&root->list_lock);
1881 1882

	if (list_empty(&BTRFS_I(inode)->i_orphan)) {
1883
		spin_unlock(&root->list_lock);
1884 1885 1886 1887 1888
		return 0;
	}

	list_del_init(&BTRFS_I(inode)->i_orphan);
	if (!trans) {
1889
		spin_unlock(&root->list_lock);
1890 1891 1892
		return 0;
	}

1893
	spin_unlock(&root->list_lock);
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961

	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.
		 */
1962 1963 1964 1965 1966
		found_key.objectid = found_key.offset;
		found_key.type = BTRFS_INODE_ITEM_KEY;
		found_key.offset = 0;
		inode = btrfs_iget(root->fs_info->sb, &found_key, root);
		if (IS_ERR(inode))
1967 1968 1969 1970 1971 1972
			break;

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

		/*
		 * 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)) {
1984
			trans = btrfs_start_transaction(root, 1);
1985
			btrfs_orphan_del(trans, inode);
1986
			btrfs_end_transaction(trans, root);
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
			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);
}

2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
/*
 * very simple check to peek ahead in the leaf looking for xattrs.  If we
 * don't find any xattrs, we know there can't be any acls.
 *
 * slot is the slot the inode is in, objectid is the objectid of the inode
 */
static noinline int acls_after_inode_item(struct extent_buffer *leaf,
					  int slot, u64 objectid)
{
	u32 nritems = btrfs_header_nritems(leaf);
	struct btrfs_key found_key;
	int scanned = 0;

	slot++;
	while (slot < nritems) {
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		/* we found a different objectid, there must not be acls */
		if (found_key.objectid != objectid)
			return 0;

		/* we found an xattr, assume we've got an acl */
		if (found_key.type == BTRFS_XATTR_ITEM_KEY)
			return 1;

		/*
		 * we found a key greater than an xattr key, there can't
		 * be any acls later on
		 */
		if (found_key.type > BTRFS_XATTR_ITEM_KEY)
			return 0;

		slot++;
		scanned++;

		/*
		 * it goes inode, inode backrefs, xattrs, extents,
		 * so if there are a ton of hard links to an inode there can
		 * be a lot of backrefs.  Don't waste time searching too hard,
		 * this is just an optimization
		 */
		if (scanned >= 8)
			break;
	}
	/* we hit the end of the leaf before we found an xattr or
	 * something larger than an xattr.  We have to assume the inode
	 * has acls
	 */
	return 1;
}

C
Chris Mason 已提交
2062 2063 2064
/*
 * read an inode from the btree into the in-memory inode
 */
2065
static void btrfs_read_locked_inode(struct inode *inode)
C
Chris Mason 已提交
2066 2067
{
	struct btrfs_path *path;
2068
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2069
	struct btrfs_inode_item *inode_item;
2070
	struct btrfs_timespec *tspec;
C
Chris Mason 已提交
2071 2072
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
2073
	int maybe_acls;
C
Chris Mason 已提交
2074
	u64 alloc_group_block;
J
Josef Bacik 已提交
2075
	u32 rdev;
C
Chris Mason 已提交
2076 2077 2078 2079 2080
	int ret;

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

C
Chris Mason 已提交
2082
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
2083
	if (ret)
C
Chris Mason 已提交
2084 2085
		goto make_bad;

2086 2087 2088 2089 2090 2091 2092 2093
	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);
2094
	btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107

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

2108
	inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
2109
	BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
2110
	BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
2111
	inode->i_generation = BTRFS_I(inode)->generation;
J
Josef Bacik 已提交
2112
	inode->i_rdev = 0;
2113 2114
	rdev = btrfs_inode_rdev(leaf, inode_item);

2115
	BTRFS_I(inode)->index_cnt = (u64)-1;
2116
	BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
2117

2118
	alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
2119

2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
	/*
	 * try to precache a NULL acl entry for files that don't have
	 * any xattrs or acls
	 */
	maybe_acls = acls_after_inode_item(leaf, path->slots[0], inode->i_ino);
	if (!maybe_acls) {
		BTRFS_I(inode)->i_acl = NULL;
		BTRFS_I(inode)->i_default_acl = NULL;
	}

2130 2131
	BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
						alloc_group_block, 0);
C
Chris Mason 已提交
2132 2133 2134 2135 2136 2137
	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 已提交
2138
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
2139
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
		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 已提交
2153
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
2154
		break;
J
Josef Bacik 已提交
2155
	default:
J
Jim Owens 已提交
2156
		inode->i_op = &btrfs_special_inode_operations;
J
Josef Bacik 已提交
2157 2158
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
2159
	}
2160 2161

	btrfs_update_iflags(inode);
C
Chris Mason 已提交
2162 2163 2164 2165 2166 2167 2168
	return;

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

C
Chris Mason 已提交
2169 2170 2171
/*
 * given a leaf and an inode, copy the inode fields into the leaf
 */
2172 2173
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
2174
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
2175 2176
			    struct inode *inode)
{
2177 2178
	btrfs_set_inode_uid(leaf, item, inode->i_uid);
	btrfs_set_inode_gid(leaf, item, inode->i_gid);
2179
	btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
	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);

2198
	btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
2199
	btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
2200
	btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
2201
	btrfs_set_inode_transid(leaf, item, trans->transid);
2202
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
Y
Yan 已提交
2203
	btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2204
	btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
C
Chris Mason 已提交
2205 2206
}

C
Chris Mason 已提交
2207 2208 2209
/*
 * copy everything in the in-memory inode into the btree.
 */
C
Chris Mason 已提交
2210 2211
noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
				struct btrfs_root *root, struct inode *inode)
C
Chris Mason 已提交
2212 2213 2214
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
2215
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2216 2217 2218 2219
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
2220
	path->leave_spinning = 1;
C
Chris Mason 已提交
2221 2222 2223 2224 2225 2226 2227 2228
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, 1);
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

2229
	btrfs_unlock_up_safe(path, 1);
2230 2231
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2232 2233
				  struct btrfs_inode_item);

2234
	fill_inode_item(trans, leaf, inode_item, inode);
2235
	btrfs_mark_buffer_dirty(leaf);
2236
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
2237 2238 2239 2240 2241 2242 2243
	ret = 0;
failed:
	btrfs_free_path(path);
	return ret;
}


C
Chris Mason 已提交
2244 2245 2246 2247 2248
/*
 * 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
 */
2249 2250 2251 2252
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 已提交
2253 2254 2255
{
	struct btrfs_path *path;
	int ret = 0;
2256
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2257
	struct btrfs_dir_item *di;
2258
	struct btrfs_key key;
2259
	u64 index;
C
Chris Mason 已提交
2260 2261

	path = btrfs_alloc_path();
2262 2263 2264 2265 2266
	if (!path) {
		ret = -ENOMEM;
		goto err;
	}

2267
	path->leave_spinning = 1;
C
Chris Mason 已提交
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
	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;
	}
2278 2279
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
2280
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
2281 2282
	if (ret)
		goto err;
C
Chris Mason 已提交
2283 2284
	btrfs_release_path(root, path);

2285
	ret = btrfs_del_inode_ref(trans, root, name, name_len,
2286 2287
				  inode->i_ino,
				  dir->i_ino, &index);
2288
	if (ret) {
C
Chris Mason 已提交
2289
		printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
2290
		       "inode %lu parent %lu\n", name_len, name,
2291
		       inode->i_ino, dir->i_ino);
2292 2293 2294
		goto err;
	}

C
Chris Mason 已提交
2295
	di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
2296
					 index, name, name_len, -1);
C
Chris Mason 已提交
2297 2298 2299 2300 2301 2302 2303 2304 2305
	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);
2306
	btrfs_release_path(root, path);
C
Chris Mason 已提交
2307

2308 2309
	ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
					 inode, dir->i_ino);
C
Chris Mason 已提交
2310
	BUG_ON(ret != 0 && ret != -ENOENT);
2311 2312 2313 2314

	ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
					   dir, index);
	BUG_ON(ret);
C
Chris Mason 已提交
2315 2316
err:
	btrfs_free_path(path);
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326
	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 已提交
2327 2328 2329 2330 2331 2332 2333
	return ret;
}

static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root;
	struct btrfs_trans_handle *trans;
2334
	struct inode *inode = dentry->d_inode;
C
Chris Mason 已提交
2335
	int ret;
2336
	unsigned long nr = 0;
C
Chris Mason 已提交
2337 2338

	root = BTRFS_I(dir)->root;
2339

C
Chris Mason 已提交
2340
	trans = btrfs_start_transaction(root, 1);
2341

C
Chris Mason 已提交
2342
	btrfs_set_trans_block_group(trans, dir);
2343 2344 2345

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

2346 2347
	ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
2348 2349 2350 2351

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

2352
	nr = trans->blocks_used;
2353

2354
	btrfs_end_transaction_throttle(trans, root);
2355
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2356 2357 2358 2359 2360 2361
	return ret;
}

static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
2362
	int err = 0;
C
Chris Mason 已提交
2363 2364 2365
	int ret;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
2366
	unsigned long nr = 0;
C
Chris Mason 已提交
2367

2368 2369 2370 2371 2372 2373
	/*
	 * 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 已提交
2374
		return -ENOTEMPTY;
2375
	}
Y
Yan 已提交
2376

C
Chris Mason 已提交
2377 2378 2379
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

2380 2381 2382 2383
	err = btrfs_orphan_add(trans, inode);
	if (err)
		goto fail_trans;

C
Chris Mason 已提交
2384
	/* now the directory is empty */
2385 2386
	err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
				 dentry->d_name.name, dentry->d_name.len);
C
Chris Mason 已提交
2387
	if (!err)
2388
		btrfs_i_size_write(inode, 0);
2389

2390
fail_trans:
2391
	nr = trans->blocks_used;
2392
	ret = btrfs_end_transaction_throttle(trans, root);
2393
	btrfs_btree_balance_dirty(root, nr);
2394

C
Chris Mason 已提交
2395 2396 2397 2398 2399
	if (ret && !err)
		err = ret;
	return err;
}

2400
#if 0
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
/*
 * 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 已提交
2429 2430 2431
	struct btrfs_leaf_ref *ref;
	u64 leaf_gen;
	u64 leaf_start;
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524

	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 已提交
2525 2526
	leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);
	leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);
2527 2528 2529 2530
	/*
	 * it is safe to delete this leaf, it contains only
	 * csum items from this inode at an offset >= new_size
	 */
Y
Yan Zheng 已提交
2531
	ret = btrfs_del_leaf(trans, root, path, leaf_start);
2532 2533
	BUG_ON(ret);

Y
Yan Zheng 已提交
2534 2535 2536 2537 2538 2539 2540 2541 2542
	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;

2543 2544
			btrfs_sort_leaf_ref(ref);

Y
Yan Zheng 已提交
2545 2546 2547 2548 2549 2550 2551
			ret = btrfs_add_leaf_ref(root, ref, 0);
			WARN_ON(ret);
			btrfs_free_leaf_ref(root, ref);
		} else {
			WARN_ON(1);
		}
	}
2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
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;
}

2570 2571
#endif

C
Chris Mason 已提交
2572 2573 2574
/*
 * 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 已提交
2575
 * any higher than new_size
C
Chris Mason 已提交
2576 2577 2578
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
2579 2580 2581
 *
 * 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 已提交
2582
 */
2583 2584 2585 2586
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 已提交
2587 2588 2589 2590
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;
2591
	struct btrfs_key found_key;
2592
	u32 found_type = (u8)-1;
2593
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2594 2595
	struct btrfs_file_extent_item *fi;
	u64 extent_start = 0;
2596
	u64 extent_num_bytes = 0;
2597
	u64 extent_offset = 0;
C
Chris Mason 已提交
2598 2599 2600
	u64 item_end = 0;
	int found_extent;
	int del_item;
2601 2602
	int pending_del_nr = 0;
	int pending_del_slot = 0;
2603
	int extent_type = -1;
2604
	int encoding;
2605
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
2606

2607
	if (root->ref_cows)
2608
		btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
C
Chris Mason 已提交
2609 2610
	path = btrfs_alloc_path();
	BUG_ON(!path);
J
Julia Lawall 已提交
2611
	path->reada = -1;
2612

C
Chris Mason 已提交
2613 2614 2615
	/* FIXME, add redo link to tree so we don't leak on crash */
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
2616 2617
	key.type = (u8)-1;

2618
search_again:
2619
	path->leave_spinning = 1;
2620
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
C
Chris Mason 已提交
2621
	if (ret < 0)
2622
		goto error;
C
Chris Mason 已提交
2623

2624
	if (ret > 0) {
2625 2626 2627 2628 2629 2630 2631
		/* there are no items in the tree for us to truncate, we're
		 * done
		 */
		if (path->slots[0] == 0) {
			ret = 0;
			goto error;
		}
2632 2633 2634
		path->slots[0]--;
	}

C
Chris Mason 已提交
2635
	while (1) {
C
Chris Mason 已提交
2636
		fi = NULL;
2637 2638 2639
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		found_type = btrfs_key_type(&found_key);
2640
		encoding = 0;
C
Chris Mason 已提交
2641

2642
		if (found_key.objectid != inode->i_ino)
C
Chris Mason 已提交
2643
			break;
2644

2645
		if (found_type < min_type)
C
Chris Mason 已提交
2646 2647
			break;

2648
		item_end = found_key.offset;
C
Chris Mason 已提交
2649
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
2650
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
2651
					    struct btrfs_file_extent_item);
2652
			extent_type = btrfs_file_extent_type(leaf, fi);
2653 2654 2655 2656
			encoding = btrfs_file_extent_compression(leaf, fi);
			encoding |= btrfs_file_extent_encryption(leaf, fi);
			encoding |= btrfs_file_extent_other_encoding(leaf, fi);

2657
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
2658
				item_end +=
2659
				    btrfs_file_extent_num_bytes(leaf, fi);
2660 2661
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				item_end += btrfs_file_extent_inline_len(leaf,
C
Chris Mason 已提交
2662
									 fi);
C
Chris Mason 已提交
2663
			}
2664
			item_end--;
C
Chris Mason 已提交
2665
		}
2666
		if (item_end < new_size) {
C
Chris Mason 已提交
2667
			if (found_type == BTRFS_DIR_ITEM_KEY)
2668
				found_type = BTRFS_INODE_ITEM_KEY;
C
Chris Mason 已提交
2669
			else if (found_type == BTRFS_EXTENT_ITEM_KEY)
2670
				found_type = BTRFS_EXTENT_DATA_KEY;
C
Chris Mason 已提交
2671
			else if (found_type == BTRFS_EXTENT_DATA_KEY)
2672
				found_type = BTRFS_XATTR_ITEM_KEY;
C
Chris Mason 已提交
2673
			else if (found_type == BTRFS_XATTR_ITEM_KEY)
2674
				found_type = BTRFS_INODE_REF_KEY;
C
Chris Mason 已提交
2675
			else if (found_type)
2676
				found_type--;
C
Chris Mason 已提交
2677
			else
2678
				break;
2679
			btrfs_set_key_type(&key, found_type);
2680
			goto next;
C
Chris Mason 已提交
2681
		}
2682
		if (found_key.offset >= new_size)
C
Chris Mason 已提交
2683 2684 2685 2686 2687 2688
			del_item = 1;
		else
			del_item = 0;
		found_extent = 0;

		/* FIXME, shrink the extent if the ref count is only 1 */
2689 2690 2691 2692
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2693
			u64 num_dec;
2694
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
2695
			if (!del_item && !encoding) {
2696 2697
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
2698
				extent_num_bytes = new_size -
2699
					found_key.offset + root->sectorsize - 1;
2700 2701
				extent_num_bytes = extent_num_bytes &
					~((u64)root->sectorsize - 1);
2702 2703 2704
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
C
Chris Mason 已提交
2705
					   extent_num_bytes);
2706
				if (root->ref_cows && extent_start != 0)
2707
					inode_sub_bytes(inode, num_dec);
2708
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2709
			} else {
2710 2711 2712
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
2713 2714 2715
				extent_offset = found_key.offset -
					btrfs_file_extent_offset(leaf, fi);

C
Chris Mason 已提交
2716
				/* FIXME blocksize != 4096 */
C
Chris Mason 已提交
2717
				num_dec = btrfs_file_extent_num_bytes(leaf, fi);
C
Chris Mason 已提交
2718 2719
				if (extent_start != 0) {
					found_extent = 1;
2720
					if (root->ref_cows)
2721
						inode_sub_bytes(inode, num_dec);
2722
				}
C
Chris Mason 已提交
2723
			}
C
Chris Mason 已提交
2724
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
2725 2726 2727 2728 2729 2730 2731 2732
			/*
			 * 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) {
2733 2734 2735
				u32 size = new_size - found_key.offset;

				if (root->ref_cows) {
2736 2737
					inode_sub_bytes(inode, item_end + 1 -
							new_size);
2738 2739 2740
				}
				size =
				    btrfs_file_extent_calc_inline_size(size);
C
Chris Mason 已提交
2741
				ret = btrfs_truncate_item(trans, root, path,
2742
							  size, 1);
C
Chris Mason 已提交
2743
				BUG_ON(ret);
2744
			} else if (root->ref_cows) {
2745 2746
				inode_sub_bytes(inode, item_end + 1 -
						found_key.offset);
C
Chris Mason 已提交
2747
			}
C
Chris Mason 已提交
2748
		}
2749
delete:
C
Chris Mason 已提交
2750
		if (del_item) {
2751 2752 2753 2754 2755 2756 2757 2758 2759 2760
			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 已提交
2761
				BUG();
2762
			}
C
Chris Mason 已提交
2763 2764 2765
		} else {
			break;
		}
2766
		if (found_extent && root->ref_cows) {
2767
			btrfs_set_path_blocking(path);
C
Chris Mason 已提交
2768
			ret = btrfs_free_extent(trans, root, extent_start,
2769 2770 2771
						extent_num_bytes, 0,
						btrfs_header_owner(leaf),
						inode->i_ino, extent_offset);
C
Chris Mason 已提交
2772 2773
			BUG_ON(ret);
		}
2774 2775 2776 2777 2778
next:
		if (path->slots[0] == 0) {
			if (pending_del_nr)
				goto del_pending;
			btrfs_release_path(root, path);
2779 2780
			if (found_type == BTRFS_INODE_ITEM_KEY)
				break;
2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796
			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);
2797 2798
			if (found_type == BTRFS_INODE_ITEM_KEY)
				break;
2799 2800
			goto search_again;
		}
C
Chris Mason 已提交
2801 2802 2803
	}
	ret = 0;
error:
2804 2805 2806 2807
	if (pending_del_nr) {
		ret = btrfs_del_items(trans, root, path, pending_del_slot,
				      pending_del_nr);
	}
C
Chris Mason 已提交
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
	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;
2820
	struct btrfs_root *root = BTRFS_I(inode)->root;
2821 2822 2823
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_ordered_extent *ordered;
	char *kaddr;
2824
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
2825 2826 2827 2828
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
	int ret = 0;
2829
	u64 page_start;
2830
	u64 page_end;
C
Chris Mason 已提交
2831 2832 2833 2834 2835

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

	ret = -ENOMEM;
2836
again:
C
Chris Mason 已提交
2837 2838 2839
	page = grab_cache_page(mapping, index);
	if (!page)
		goto out;
2840 2841 2842 2843

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

C
Chris Mason 已提交
2844
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
2845
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
2846
		lock_page(page);
2847 2848 2849 2850 2851
		if (page->mapping != mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}
C
Chris Mason 已提交
2852 2853
		if (!PageUptodate(page)) {
			ret = -EIO;
2854
			goto out_unlock;
C
Chris Mason 已提交
2855 2856
		}
	}
2857
	wait_on_page_writeback(page);
2858 2859 2860 2861 2862 2863 2864 2865 2866

	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);
2867
		btrfs_start_ordered_extent(inode, ordered, 1);
2868 2869 2870 2871
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

2872
	btrfs_set_extent_delalloc(inode, page_start, page_end);
2873 2874 2875 2876 2877 2878 2879
	ret = 0;
	if (offset != PAGE_CACHE_SIZE) {
		kaddr = kmap(page);
		memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
		flush_dcache_page(page);
		kunmap(page);
	}
2880
	ClearPageChecked(page);
2881 2882
	set_page_dirty(page);
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
2883

2884
out_unlock:
C
Chris Mason 已提交
2885 2886 2887 2888 2889 2890
	unlock_page(page);
	page_cache_release(page);
out:
	return ret;
}

Y
Yan Zheng 已提交
2891
int btrfs_cont_expand(struct inode *inode, loff_t size)
C
Chris Mason 已提交
2892
{
Y
Yan Zheng 已提交
2893 2894 2895 2896 2897 2898 2899 2900 2901 2902
	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 已提交
2903 2904
	int err;

Y
Yan Zheng 已提交
2905 2906 2907
	if (size <= hole_start)
		return 0;

J
Josef Bacik 已提交
2908
	err = btrfs_check_metadata_free_space(root);
C
Chris Mason 已提交
2909 2910 2911
	if (err)
		return err;

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

Y
Yan Zheng 已提交
2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924
	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 已提交
2925

Y
Yan Zheng 已提交
2926 2927
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
C
Chris Mason 已提交
2928

Y
Yan Zheng 已提交
2929 2930 2931 2932 2933 2934 2935 2936
	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)) {
2937
			u64 hint_byte = 0;
Y
Yan Zheng 已提交
2938
			hole_size = last_byte - cur_offset;
2939 2940 2941
			err = btrfs_drop_extents(trans, root, inode,
						 cur_offset,
						 cur_offset + hole_size,
2942
						 block_end,
2943 2944 2945
						 cur_offset, &hint_byte);
			if (err)
				break;
Y
Yan Zheng 已提交
2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957
			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;
	}
2958

Y
Yan Zheng 已提交
2959 2960 2961 2962
	btrfs_end_transaction(trans, root);
	unlock_extent(io_tree, hole_start, block_end - 1, GFP_NOFS);
	return err;
}
C
Chris Mason 已提交
2963

Y
Yan Zheng 已提交
2964 2965 2966 2967
static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int err;
C
Chris Mason 已提交
2968

Y
Yan Zheng 已提交
2969 2970 2971
	err = inode_change_ok(inode, attr);
	if (err)
		return err;
C
Chris Mason 已提交
2972

2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
	if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
		if (attr->ia_size > inode->i_size) {
			err = btrfs_cont_expand(inode, attr->ia_size);
			if (err)
				return err;
		} else if (inode->i_size > 0 &&
			   attr->ia_size == 0) {

			/* we're truncating a file that used to have good
			 * data down to zero.  Make sure it gets into
			 * the ordered flush list so that any new writes
			 * get down to disk quickly.
			 */
			BTRFS_I(inode)->ordered_data_close = 1;
		}
C
Chris Mason 已提交
2988
	}
Y
Yan Zheng 已提交
2989

C
Chris Mason 已提交
2990
	err = inode_setattr(inode, attr);
J
Josef Bacik 已提交
2991 2992 2993

	if (!err && ((attr->ia_valid & ATTR_MODE)))
		err = btrfs_acl_chmod(inode);
C
Chris Mason 已提交
2994 2995
	return err;
}
2996

C
Chris Mason 已提交
2997 2998 2999 3000
void btrfs_delete_inode(struct inode *inode)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
3001
	unsigned long nr;
C
Chris Mason 已提交
3002 3003 3004 3005
	int ret;

	truncate_inode_pages(&inode->i_data, 0);
	if (is_bad_inode(inode)) {
3006
		btrfs_orphan_del(NULL, inode);
C
Chris Mason 已提交
3007 3008
		goto no_delete;
	}
C
Chris Mason 已提交
3009
	btrfs_wait_ordered_range(inode, 0, (u64)-1);
3010

3011
	btrfs_i_size_write(inode, 0);
3012
	trans = btrfs_join_transaction(root, 1);
3013

C
Chris Mason 已提交
3014
	btrfs_set_trans_block_group(trans, inode);
3015
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size, 0);
3016 3017
	if (ret) {
		btrfs_orphan_del(NULL, inode);
3018
		goto no_delete_lock;
3019 3020 3021
	}

	btrfs_orphan_del(trans, inode);
3022

3023
	nr = trans->blocks_used;
3024
	clear_inode(inode);
3025

C
Chris Mason 已提交
3026
	btrfs_end_transaction(trans, root);
3027
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3028
	return;
3029 3030

no_delete_lock:
3031
	nr = trans->blocks_used;
3032
	btrfs_end_transaction(trans, root);
3033
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
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 已提交
3050
	int ret = 0;
C
Chris Mason 已提交
3051 3052 3053

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

C
Chris Mason 已提交
3055 3056
	di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
				    namelen, 0);
Y
Yan 已提交
3057 3058
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
3059 3060

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

3063
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
3064 3065 3066
out:
	btrfs_free_path(path);
	return ret;
3067 3068 3069
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
3070 3071 3072 3073 3074 3075 3076 3077 3078
}

/*
 * 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,
3079 3080
			     struct btrfs_root **sub_root,
			     struct dentry *dentry)
C
Chris Mason 已提交
3081 3082 3083 3084 3085 3086 3087 3088
{
	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;

3089 3090 3091
	*sub_root = btrfs_read_fs_root(root->fs_info, location,
					dentry->d_name.name,
					dentry->d_name.len);
C
Chris Mason 已提交
3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102
	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;
}

3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
static void inode_tree_add(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_inode *entry;
	struct rb_node **p = &root->inode_tree.rb_node;
	struct rb_node *parent = NULL;

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

		if (inode->i_ino < entry->vfs_inode.i_ino)
			p = &(*p)->rb_left;
		else if (inode->i_ino > entry->vfs_inode.i_ino)
			p = &(*p)->rb_right;
		else {
			WARN_ON(!(entry->vfs_inode.i_state &
				  (I_WILL_FREE | I_FREEING | I_CLEAR)));
			break;
		}
	}
	rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
	rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
	spin_unlock(&root->inode_lock);
}

static void inode_tree_del(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;

	if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
		spin_lock(&root->inode_lock);
		rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
		spin_unlock(&root->inode_lock);
		RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
	}
}

3142
static noinline void init_btrfs_i(struct inode *inode)
C
Chris Mason 已提交
3143
{
3144 3145
	struct btrfs_inode *bi = BTRFS_I(inode);

C
Chris Mason 已提交
3146 3147
	bi->i_acl = BTRFS_ACL_NOT_CACHED;
	bi->i_default_acl = BTRFS_ACL_NOT_CACHED;
3148 3149

	bi->generation = 0;
3150
	bi->sequence = 0;
3151 3152 3153
	bi->last_trans = 0;
	bi->logged_trans = 0;
	bi->delalloc_bytes = 0;
J
Josef Bacik 已提交
3154
	bi->reserved_bytes = 0;
3155 3156 3157
	bi->disk_i_size = 0;
	bi->flags = 0;
	bi->index_cnt = (u64)-1;
3158
	bi->last_unlink_trans = 0;
3159
	bi->ordered_data_close = 0;
3160 3161
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
	extent_io_tree_init(&BTRFS_I(inode)->io_tree,
3162
			     inode->i_mapping, GFP_NOFS);
3163 3164
	extent_io_tree_init(&BTRFS_I(inode)->io_failure_tree,
			     inode->i_mapping, GFP_NOFS);
3165
	INIT_LIST_HEAD(&BTRFS_I(inode)->delalloc_inodes);
3166
	INIT_LIST_HEAD(&BTRFS_I(inode)->ordered_operations);
3167
	RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
3168
	btrfs_ordered_inode_tree_init(&BTRFS_I(inode)->ordered_tree);
3169
	mutex_init(&BTRFS_I(inode)->extent_mutex);
3170 3171 3172 3173 3174 3175 3176 3177 3178
	mutex_init(&BTRFS_I(inode)->log_mutex);
}

static int btrfs_init_locked_inode(struct inode *inode, void *p)
{
	struct btrfs_iget_args *args = p;
	inode->i_ino = args->ino;
	init_btrfs_i(inode);
	BTRFS_I(inode)->root = args->root;
J
Josef Bacik 已提交
3179
	btrfs_set_inode_space_info(args->root, inode);
C
Chris Mason 已提交
3180 3181 3182 3183 3184 3185
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
C
Chris Mason 已提交
3186 3187
	return args->ino == inode->i_ino &&
		args->root == BTRFS_I(inode)->root;
C
Chris Mason 已提交
3188 3189
}

3190 3191 3192
static struct inode *btrfs_iget_locked(struct super_block *s,
				       u64 objectid,
				       struct btrfs_root *root)
C
Chris Mason 已提交
3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204
{
	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 已提交
3205 3206 3207 3208
/* 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,
3209
			 struct btrfs_root *root)
B
Balaji Rao 已提交
3210 3211 3212 3213 3214
{
	struct inode *inode;

	inode = btrfs_iget_locked(s, location->objectid, root);
	if (!inode)
3215
		return ERR_PTR(-ENOMEM);
B
Balaji Rao 已提交
3216 3217 3218 3219 3220

	if (inode->i_state & I_NEW) {
		BTRFS_I(inode)->root = root;
		memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
		btrfs_read_locked_inode(inode);
3221 3222

		inode_tree_add(inode);
B
Balaji Rao 已提交
3223 3224 3225 3226 3227 3228
		unlock_new_inode(inode);
	}

	return inode;
}

3229
struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
C
Chris Mason 已提交
3230
{
C
Chris Mason 已提交
3231
	struct inode *inode;
C
Chris Mason 已提交
3232 3233 3234 3235
	struct btrfs_inode *bi = BTRFS_I(dir);
	struct btrfs_root *root = bi->root;
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
3236
	int ret;
C
Chris Mason 已提交
3237 3238 3239

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

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

C
Chris Mason 已提交
3243 3244
	if (ret < 0)
		return ERR_PTR(ret);
3245

C
Chris Mason 已提交
3246 3247
	inode = NULL;
	if (location.objectid) {
3248 3249
		ret = fixup_tree_root_location(root, &location, &sub_root,
						dentry);
C
Chris Mason 已提交
3250 3251 3252 3253
		if (ret < 0)
			return ERR_PTR(ret);
		if (ret > 0)
			return ERR_PTR(-ENOENT);
3254
		inode = btrfs_iget(dir->i_sb, &location, sub_root);
B
Balaji Rao 已提交
3255 3256
		if (IS_ERR(inode))
			return ERR_CAST(inode);
C
Chris Mason 已提交
3257
	}
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271
	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);
3272

C
Chris Mason 已提交
3273 3274 3275 3276 3277 3278 3279
	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
};

3280 3281
static int btrfs_real_readdir(struct file *filp, void *dirent,
			      filldir_t filldir)
C
Chris Mason 已提交
3282
{
3283
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
3284 3285 3286 3287
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
3288
	struct btrfs_key found_key;
C
Chris Mason 已提交
3289 3290 3291
	struct btrfs_path *path;
	int ret;
	u32 nritems;
3292
	struct extent_buffer *leaf;
C
Chris Mason 已提交
3293 3294 3295 3296 3297 3298 3299 3300
	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;
3301 3302 3303
	char tmp_name[32];
	char *name_ptr;
	int name_len;
C
Chris Mason 已提交
3304 3305 3306 3307

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

3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319
	/* 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) {
3320
		u64 pino = parent_ino(filp->f_path.dentry);
3321
		over = filldir(dirent, "..", 2,
3322
			       2, pino, DT_DIR);
3323
		if (over)
3324
			return 0;
3325 3326
		filp->f_pos = 2;
	}
3327 3328 3329
	path = btrfs_alloc_path();
	path->reada = 2;

C
Chris Mason 已提交
3330 3331
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
3332
	key.objectid = inode->i_ino;
3333

C
Chris Mason 已提交
3334 3335 3336 3337
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
	advance = 0;
3338 3339

	while (1) {
3340 3341
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3342 3343
		slot = path->slots[0];
		if (advance || slot >= nritems) {
3344
			if (slot >= nritems - 1) {
C
Chris Mason 已提交
3345 3346 3347
				ret = btrfs_next_leaf(root, path);
				if (ret)
					break;
3348 3349
				leaf = path->nodes[0];
				nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
3350 3351 3352 3353 3354 3355
				slot = path->slots[0];
			} else {
				slot++;
				path->slots[0]++;
			}
		}
3356

C
Chris Mason 已提交
3357
		advance = 1;
3358 3359 3360 3361
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
3362
			break;
3363
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
3364
			break;
3365
		if (found_key.offset < filp->f_pos)
C
Chris Mason 已提交
3366
			continue;
3367 3368

		filp->f_pos = found_key.offset;
3369

C
Chris Mason 已提交
3370 3371
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
3372
		di_total = btrfs_item_size(leaf, item);
3373 3374

		while (di_cur < di_total) {
3375 3376 3377
			struct btrfs_key location;

			name_len = btrfs_dir_name_len(leaf, di);
3378
			if (name_len <= sizeof(tmp_name)) {
3379 3380 3381
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
3382 3383 3384 3385
				if (!name_ptr) {
					ret = -ENOMEM;
					goto err;
				}
3386 3387 3388 3389 3390 3391
			}
			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);
3392 3393 3394 3395 3396 3397 3398 3399 3400

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

3405
skip:
3406 3407 3408
			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
3409 3410
			if (over)
				goto nopos;
J
Josef Bacik 已提交
3411
			di_len = btrfs_dir_name_len(leaf, di) +
3412
				 btrfs_dir_data_len(leaf, di) + sizeof(*di);
C
Chris Mason 已提交
3413 3414 3415 3416
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
	}
3417 3418

	/* Reached end of directory/root. Bump pos past the last item. */
3419
	if (key_type == BTRFS_DIR_INDEX_KEY)
3420
		filp->f_pos = INT_LIMIT(off_t);
3421 3422
	else
		filp->f_pos++;
C
Chris Mason 已提交
3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
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 已提交
3436
	if (root->fs_info->btree_inode == inode)
3437 3438
		return 0;

C
Chris Mason 已提交
3439
	if (wait) {
3440
		trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3441 3442 3443 3444 3445 3446 3447
		btrfs_set_trans_block_group(trans, inode);
		ret = btrfs_commit_transaction(trans, root);
	}
	return ret;
}

/*
3448
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
3449 3450 3451 3452 3453 3454 3455 3456 3457
 * 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;

3458
	trans = btrfs_join_transaction(root, 1);
C
Chris Mason 已提交
3459 3460 3461 3462 3463
	btrfs_set_trans_block_group(trans, inode);
	btrfs_update_inode(trans, root, inode);
	btrfs_end_transaction(trans, root);
}

C
Chris Mason 已提交
3464 3465 3466 3467 3468
/*
 * find the highest existing sequence number in a directory
 * and then set the in-memory index_cnt variable to reflect
 * free sequence numbers
 */
3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520
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 已提交
3521 3522 3523 3524
/*
 * 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
 */
3525
int btrfs_set_inode_index(struct inode *dir, u64 *index)
3526 3527 3528 3529 3530
{
	int ret = 0;

	if (BTRFS_I(dir)->index_cnt == (u64)-1) {
		ret = btrfs_set_inode_index_count(dir);
C
Chris Mason 已提交
3531
		if (ret)
3532 3533 3534
			return ret;
	}

3535
	*index = BTRFS_I(dir)->index_cnt;
3536 3537 3538 3539 3540
	BTRFS_I(dir)->index_cnt++;

	return ret;
}

C
Chris Mason 已提交
3541 3542
static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
3543
				     struct inode *dir,
3544
				     const char *name, int name_len,
3545 3546
				     u64 ref_objectid, u64 objectid,
				     u64 alloc_hint, int mode, u64 *index)
C
Chris Mason 已提交
3547 3548
{
	struct inode *inode;
3549
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
3550
	struct btrfs_key *location;
3551
	struct btrfs_path *path;
3552 3553 3554 3555
	struct btrfs_inode_ref *ref;
	struct btrfs_key key[2];
	u32 sizes[2];
	unsigned long ptr;
C
Chris Mason 已提交
3556 3557 3558
	int ret;
	int owner;

3559 3560 3561
	path = btrfs_alloc_path();
	BUG_ON(!path);

C
Chris Mason 已提交
3562 3563 3564 3565
	inode = new_inode(root->fs_info->sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

3566
	if (dir) {
3567
		ret = btrfs_set_inode_index(dir, index);
3568 3569
		if (ret) {
			iput(inode);
3570
			return ERR_PTR(ret);
3571
		}
3572 3573 3574 3575 3576 3577
	}
	/*
	 * index_cnt is ignored for everything but a dir,
	 * btrfs_get_inode_index_count has an explanation for the magic
	 * number
	 */
3578
	init_btrfs_i(inode);
3579
	BTRFS_I(inode)->index_cnt = 2;
C
Chris Mason 已提交
3580
	BTRFS_I(inode)->root = root;
3581
	BTRFS_I(inode)->generation = trans->transid;
J
Josef Bacik 已提交
3582
	btrfs_set_inode_space_info(root, inode);
3583

C
Chris Mason 已提交
3584 3585 3586 3587
	if (mode & S_IFDIR)
		owner = 0;
	else
		owner = 1;
3588 3589
	BTRFS_I(inode)->block_group =
			btrfs_find_block_group(root, 0, alloc_hint, owner);
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601

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

3602
	path->leave_spinning = 1;
3603 3604
	ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
	if (ret != 0)
3605 3606
		goto fail;

3607 3608 3609
	if (objectid > root->highest_inode)
		root->highest_inode = objectid;

C
Chris Mason 已提交
3610
	inode->i_uid = current_fsuid();
3611

3612
	if (dir && (dir->i_mode & S_ISGID)) {
3613 3614 3615 3616 3617 3618
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current_fsgid();

C
Chris Mason 已提交
3619 3620
	inode->i_mode = mode;
	inode->i_ino = objectid;
3621
	inode_set_bytes(inode, 0);
C
Chris Mason 已提交
3622
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
3623 3624
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
3625
	fill_inode_item(trans, path->nodes[0], inode_item, inode);
3626 3627 3628 3629

	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);
3630
	btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
3631 3632 3633
	ptr = (unsigned long)(ref + 1);
	write_extent_buffer(path->nodes[0], name, ptr, name_len);

3634 3635 3636
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
3637 3638 3639 3640 3641
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

3642 3643
	btrfs_inherit_iflags(inode, dir);

3644 3645 3646 3647 3648 3649 3650
	if ((mode & S_IFREG)) {
		if (btrfs_test_opt(root, NODATASUM))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
		if (btrfs_test_opt(root, NODATACOW))
			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
	}

C
Chris Mason 已提交
3651
	insert_inode_hash(inode);
3652
	inode_tree_add(inode);
C
Chris Mason 已提交
3653
	return inode;
3654
fail:
3655 3656
	if (dir)
		BTRFS_I(dir)->index_cnt--;
3657
	btrfs_free_path(path);
3658
	iput(inode);
3659
	return ERR_PTR(ret);
C
Chris Mason 已提交
3660 3661 3662 3663 3664 3665 3666
}

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

C
Chris Mason 已提交
3667 3668 3669 3670 3671 3672
/*
 * 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.
 */
3673 3674 3675
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 已提交
3676 3677 3678
{
	int ret;
	struct btrfs_key key;
3679
	struct btrfs_root *root = BTRFS_I(parent_inode)->root;
3680

C
Chris Mason 已提交
3681 3682 3683 3684
	key.objectid = inode->i_ino;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
	key.offset = 0;

3685 3686
	ret = btrfs_insert_dir_item(trans, root, name, name_len,
				    parent_inode->i_ino,
3687
				    &key, btrfs_inode_type(inode),
3688
				    index);
C
Chris Mason 已提交
3689
	if (ret == 0) {
3690 3691
		if (add_backref) {
			ret = btrfs_insert_inode_ref(trans, root,
3692 3693 3694 3695
						     name, name_len,
						     inode->i_ino,
						     parent_inode->i_ino,
						     index);
3696
		}
3697
		btrfs_i_size_write(parent_inode, parent_inode->i_size +
3698
				   name_len * 2);
3699
		parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
3700
		ret = btrfs_update_inode(trans, root, parent_inode);
C
Chris Mason 已提交
3701 3702 3703 3704 3705
	}
	return ret;
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
3706
			    struct dentry *dentry, struct inode *inode,
3707
			    int backref, u64 index)
C
Chris Mason 已提交
3708
{
3709 3710 3711
	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 已提交
3712 3713 3714 3715 3716 3717 3718 3719 3720
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
3721 3722 3723 3724 3725
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;
3726
	struct inode *inode = NULL;
J
Josef Bacik 已提交
3727 3728 3729
	int err;
	int drop_inode = 0;
	u64 objectid;
3730
	unsigned long nr = 0;
3731
	u64 index = 0;
J
Josef Bacik 已提交
3732 3733 3734 3735

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

J
Josef Bacik 已提交
3736
	err = btrfs_check_metadata_free_space(root);
3737 3738 3739
	if (err)
		goto fail;

J
Josef Bacik 已提交
3740 3741 3742 3743 3744 3745 3746 3747 3748
	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;
	}

3749
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3750 3751
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3752
				BTRFS_I(dir)->block_group, mode, &index);
J
Josef Bacik 已提交
3753 3754 3755 3756
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
3757
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3758 3759 3760 3761 3762
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

J
Josef Bacik 已提交
3763
	btrfs_set_trans_block_group(trans, inode);
3764
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
J
Josef Bacik 已提交
3765 3766 3767 3768 3769
	if (err)
		drop_inode = 1;
	else {
		inode->i_op = &btrfs_special_inode_operations;
		init_special_inode(inode, inode->i_mode, rdev);
3770
		btrfs_update_inode(trans, root, inode);
J
Josef Bacik 已提交
3771 3772 3773 3774 3775
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3776
	nr = trans->blocks_used;
3777
	btrfs_end_transaction_throttle(trans, root);
3778
fail:
J
Josef Bacik 已提交
3779 3780 3781 3782
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3783
	btrfs_btree_balance_dirty(root, nr);
J
Josef Bacik 已提交
3784 3785 3786
	return err;
}

C
Chris Mason 已提交
3787 3788 3789 3790 3791
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;
3792
	struct inode *inode = NULL;
C
Chris Mason 已提交
3793 3794
	int err;
	int drop_inode = 0;
3795
	unsigned long nr = 0;
C
Chris Mason 已提交
3796
	u64 objectid;
3797
	u64 index = 0;
C
Chris Mason 已提交
3798

J
Josef Bacik 已提交
3799
	err = btrfs_check_metadata_free_space(root);
3800 3801
	if (err)
		goto fail;
C
Chris Mason 已提交
3802 3803 3804 3805 3806 3807 3808 3809 3810
	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;
	}

3811
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3812 3813
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino,
3814 3815
				objectid, BTRFS_I(dir)->block_group, mode,
				&index);
C
Chris Mason 已提交
3816 3817 3818 3819
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
3820
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3821 3822 3823 3824 3825
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
3826
	btrfs_set_trans_block_group(trans, inode);
3827
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
3828 3829 3830 3831
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
3832
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
3833 3834
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
3835
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
3836 3837 3838 3839 3840
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
3841
	nr = trans->blocks_used;
3842
	btrfs_end_transaction_throttle(trans, root);
3843
fail:
C
Chris Mason 已提交
3844 3845 3846 3847
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3848
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3849 3850 3851 3852 3853 3854 3855 3856 3857
	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;
3858
	u64 index;
3859
	unsigned long nr = 0;
C
Chris Mason 已提交
3860 3861 3862 3863 3864 3865
	int err;
	int drop_inode = 0;

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

3866
	btrfs_inc_nlink(inode);
J
Josef Bacik 已提交
3867
	err = btrfs_check_metadata_free_space(root);
3868 3869
	if (err)
		goto fail;
3870
	err = btrfs_set_inode_index(dir, &index);
3871 3872 3873
	if (err)
		goto fail;

C
Chris Mason 已提交
3874
	trans = btrfs_start_transaction(root, 1);
3875

C
Chris Mason 已提交
3876 3877
	btrfs_set_trans_block_group(trans, dir);
	atomic_inc(&inode->i_count);
3878

3879
	err = btrfs_add_nondir(trans, dentry, inode, 1, index);
3880

C
Chris Mason 已提交
3881 3882
	if (err)
		drop_inode = 1;
3883

C
Chris Mason 已提交
3884 3885
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, dir);
3886
	err = btrfs_update_inode(trans, root, inode);
3887

3888 3889
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
3890

3891
	nr = trans->blocks_used;
3892 3893

	btrfs_log_new_name(trans, inode, NULL, dentry->d_parent);
3894
	btrfs_end_transaction_throttle(trans, root);
3895
fail:
C
Chris Mason 已提交
3896 3897 3898 3899
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
3900
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3901 3902 3903 3904 3905
	return err;
}

static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
3906
	struct inode *inode = NULL;
C
Chris Mason 已提交
3907 3908 3909 3910
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
3911
	u64 objectid = 0;
3912
	u64 index = 0;
3913
	unsigned long nr = 1;
C
Chris Mason 已提交
3914

J
Josef Bacik 已提交
3915
	err = btrfs_check_metadata_free_space(root);
3916 3917 3918
	if (err)
		goto out_unlock;

C
Chris Mason 已提交
3919 3920
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);
3921

C
Chris Mason 已提交
3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
	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;
	}

3933
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
3934 3935
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
3936 3937
				BTRFS_I(dir)->block_group, S_IFDIR | mode,
				&index);
C
Chris Mason 已提交
3938 3939 3940 3941
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
3942

C
Chris Mason 已提交
3943
	drop_on_err = 1;
J
Josef Bacik 已提交
3944

J
Jim Owens 已提交
3945
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
3946 3947 3948
	if (err)
		goto out_fail;

C
Chris Mason 已提交
3949 3950 3951 3952
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;
	btrfs_set_trans_block_group(trans, inode);

3953
	btrfs_i_size_write(inode, 0);
C
Chris Mason 已提交
3954 3955 3956
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
3957

3958 3959 3960
	err = btrfs_add_link(trans, dentry->d_parent->d_inode,
				 inode, dentry->d_name.name,
				 dentry->d_name.len, 0, index);
C
Chris Mason 已提交
3961 3962
	if (err)
		goto out_fail;
3963

C
Chris Mason 已提交
3964 3965 3966 3967 3968 3969 3970
	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:
3971
	nr = trans->blocks_used;
3972
	btrfs_end_transaction_throttle(trans, root);
3973

C
Chris Mason 已提交
3974 3975 3976
out_unlock:
	if (drop_on_err)
		iput(inode);
3977
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
3978 3979 3980
	return err;
}

C
Chris Mason 已提交
3981 3982 3983 3984
/* 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.
 */
3985 3986
static int merge_extent_mapping(struct extent_map_tree *em_tree,
				struct extent_map *existing,
3987 3988
				struct extent_map *em,
				u64 map_start, u64 map_len)
3989 3990 3991
{
	u64 start_diff;

3992 3993 3994 3995
	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 已提交
3996 3997
	if (em->block_start < EXTENT_MAP_LAST_BYTE &&
	    !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
3998
		em->block_start += start_diff;
C
Chris Mason 已提交
3999 4000
		em->block_len -= start_diff;
	}
4001
	return add_extent_mapping(em_tree, em);
4002 4003
}

C
Chris Mason 已提交
4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024
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);

4025
	max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
C
Chris Mason 已提交
4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039
	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 已提交
4040 4041
/*
 * a bit scary, this does extent mapping from logical file offset to the disk.
C
Chris Mason 已提交
4042 4043
 * 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 已提交
4044 4045 4046 4047
 * where the in-ram extents might be locked pending data=ordered completion.
 *
 * This also copies inline extents directly into the page.
 */
C
Chris Mason 已提交
4048

4049
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
4050
				    size_t pg_offset, u64 start, u64 len,
4051 4052 4053 4054
				    int create)
{
	int ret;
	int err = 0;
4055
	u64 bytenr;
4056 4057 4058 4059
	u64 extent_start = 0;
	u64 extent_end = 0;
	u64 objectid = inode->i_ino;
	u32 found_type;
4060
	struct btrfs_path *path = NULL;
4061 4062
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
4063 4064
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
4065 4066
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4067
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4068
	struct btrfs_trans_handle *trans = NULL;
C
Chris Mason 已提交
4069
	int compressed;
4070 4071

again:
4072 4073
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
4074 4075
	if (em)
		em->bdev = root->fs_info->fs_devices->latest_bdev;
4076 4077
	spin_unlock(&em_tree->lock);

4078
	if (em) {
4079 4080 4081
		if (em->start > start || em->start + em->len <= start)
			free_extent_map(em);
		else if (em->block_start == EXTENT_MAP_INLINE && page)
4082 4083 4084
			free_extent_map(em);
		else
			goto out;
4085
	}
4086
	em = alloc_extent_map(GFP_NOFS);
4087
	if (!em) {
4088 4089
		err = -ENOMEM;
		goto out;
4090
	}
4091
	em->bdev = root->fs_info->fs_devices->latest_bdev;
4092
	em->start = EXTENT_MAP_HOLE;
4093
	em->orig_start = EXTENT_MAP_HOLE;
4094
	em->len = (u64)-1;
C
Chris Mason 已提交
4095
	em->block_len = (u64)-1;
4096 4097 4098 4099 4100 4101

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

4102 4103
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114
	if (ret < 0) {
		err = ret;
		goto out;
	}

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

4115 4116
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
4117 4118
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
4119 4120 4121
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
4122 4123 4124 4125
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

4126 4127
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
C
Chris Mason 已提交
4128
	compressed = btrfs_file_extent_compression(leaf, item);
Y
Yan Zheng 已提交
4129 4130
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
4131
		extent_end = extent_start +
4132
		       btrfs_file_extent_num_bytes(leaf, item);
Y
Yan Zheng 已提交
4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146
	} 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;
4147
			}
Y
Yan Zheng 已提交
4148 4149 4150
			if (ret > 0)
				goto not_found;
			leaf = path->nodes[0];
4151
		}
Y
Yan Zheng 已提交
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162
		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 已提交
4163 4164
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Y
Yan Zheng 已提交
4165 4166
		em->start = extent_start;
		em->len = extent_end - extent_start;
4167 4168
		em->orig_start = extent_start -
				 btrfs_file_extent_offset(leaf, item);
4169 4170
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
4171
			em->block_start = EXTENT_MAP_HOLE;
4172 4173
			goto insert;
		}
C
Chris Mason 已提交
4174 4175 4176 4177 4178 4179 4180 4181 4182
		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 已提交
4183 4184
			if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
C
Chris Mason 已提交
4185
		}
4186 4187
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
4188
		unsigned long ptr;
4189
		char *map;
4190 4191 4192
		size_t size;
		size_t extent_offset;
		size_t copy_size;
4193

4194
		em->block_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4195
		if (!page || create) {
4196
			em->start = extent_start;
Y
Yan Zheng 已提交
4197
			em->len = extent_end - extent_start;
4198 4199
			goto out;
		}
4200

Y
Yan Zheng 已提交
4201 4202
		size = btrfs_file_extent_inline_len(leaf, item);
		extent_offset = page_offset(page) + pg_offset - extent_start;
4203
		copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
4204 4205
				size - extent_offset);
		em->start = extent_start + extent_offset;
4206 4207
		em->len = (copy_size + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
4208
		em->orig_start = EXTENT_MAP_INLINE;
C
Chris Mason 已提交
4209 4210
		if (compressed)
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
4211
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
4212
		if (create == 0 && !PageUptodate(page)) {
C
Chris Mason 已提交
4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224
			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);
			}
4225 4226 4227 4228 4229 4230 4231
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
				btrfs_release_path(root, path);
4232
				trans = btrfs_join_transaction(root, 1);
4233 4234
				goto again;
			}
C
Chris Mason 已提交
4235
			map = kmap(page);
4236
			write_extent_buffer(leaf, map + pg_offset, ptr,
4237
					    copy_size);
C
Chris Mason 已提交
4238
			kunmap(page);
4239
			btrfs_mark_buffer_dirty(leaf);
4240
		}
4241 4242
		set_extent_uptodate(io_tree, em->start,
				    extent_map_end(em) - 1, GFP_NOFS);
4243 4244
		goto insert;
	} else {
C
Chris Mason 已提交
4245
		printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
4246 4247 4248 4249
		WARN_ON(1);
	}
not_found:
	em->start = start;
4250
	em->len = len;
4251
not_found_em:
4252
	em->block_start = EXTENT_MAP_HOLE;
Y
Yan Zheng 已提交
4253
	set_bit(EXTENT_FLAG_VACANCY, &em->flags);
4254 4255
insert:
	btrfs_release_path(root, path);
4256
	if (em->start > start || extent_map_end(em) <= start) {
C
Chris Mason 已提交
4257 4258 4259 4260 4261
		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);
4262 4263 4264
		err = -EIO;
		goto out;
	}
4265 4266 4267

	err = 0;
	spin_lock(&em_tree->lock);
4268
	ret = add_extent_mapping(em_tree, em);
4269 4270 4271 4272
	/* 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
	 */
4273
	if (ret == -EEXIST) {
4274
		struct extent_map *existing;
4275 4276 4277

		ret = 0;

4278
		existing = lookup_extent_mapping(em_tree, start, len);
4279 4280 4281 4282 4283
		if (existing && (existing->start > start ||
		    existing->start + existing->len <= start)) {
			free_extent_map(existing);
			existing = NULL;
		}
4284 4285 4286 4287 4288
		if (!existing) {
			existing = lookup_extent_mapping(em_tree, em->start,
							 em->len);
			if (existing) {
				err = merge_extent_mapping(em_tree, existing,
4289 4290
							   em, start,
							   root->sectorsize);
4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303
				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;
4304
			err = 0;
4305 4306
		}
	}
4307
	spin_unlock(&em_tree->lock);
4308
out:
4309 4310
	if (path)
		btrfs_free_path(path);
4311 4312
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
4313
		if (!err)
4314 4315 4316 4317 4318 4319 4320 4321 4322
			err = ret;
	}
	if (err) {
		free_extent_map(em);
		return ERR_PTR(err);
	}
	return em;
}

4323 4324 4325 4326
static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
			const struct iovec *iov, loff_t offset,
			unsigned long nr_segs)
{
4327
	return -EINVAL;
4328 4329
}

Y
Yehuda Sadeh 已提交
4330 4331 4332 4333 4334 4335
static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		__u64 start, __u64 len)
{
	return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent);
}

4336
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
4337
{
4338 4339
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4340
	return extent_read_full_page(tree, page, btrfs_get_extent);
C
Chris Mason 已提交
4341
}
4342

4343
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
4344
{
4345
	struct extent_io_tree *tree;
4346 4347 4348 4349 4350 4351 4352


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

4357 4358
int btrfs_writepages(struct address_space *mapping,
		     struct writeback_control *wbc)
C
Chris Mason 已提交
4359
{
4360
	struct extent_io_tree *tree;
4361

4362
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4363 4364 4365
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
4366 4367 4368 4369
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
4370 4371
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
C
Chris Mason 已提交
4372 4373 4374
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}
4375
static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
C
Chris Mason 已提交
4376
{
4377 4378
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
4379
	int ret;
4380

4381 4382
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
4383
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
4384 4385 4386 4387
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
4388
	}
4389
	return ret;
C
Chris Mason 已提交
4390 4391
}

4392 4393
static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
{
4394 4395
	if (PageWriteback(page) || PageDirty(page))
		return 0;
4396
	return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
4397 4398
}

4399
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
4400
{
4401
	struct extent_io_tree *tree;
4402 4403 4404
	struct btrfs_ordered_extent *ordered;
	u64 page_start = page_offset(page);
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
C
Chris Mason 已提交
4405

4406
	wait_on_page_writeback(page);
4407
	tree = &BTRFS_I(page->mapping->host)->io_tree;
4408 4409 4410 4411 4412 4413 4414 4415 4416
	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) {
4417 4418 4419 4420
		/*
		 * IO on this page will never be started, so we need
		 * to account for any ordered extents now
		 */
4421 4422 4423
		clear_extent_bit(tree, page_start, page_end,
				 EXTENT_DIRTY | EXTENT_DELALLOC |
				 EXTENT_LOCKED, 1, 0, GFP_NOFS);
4424 4425
		btrfs_finish_ordered_io(page->mapping->host,
					page_start, page_end);
4426 4427 4428 4429 4430 4431 4432 4433 4434
		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 已提交
4435
	ClearPageChecked(page);
4436 4437 4438 4439 4440
	if (PagePrivate(page)) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
C
Chris Mason 已提交
4441 4442
}

C
Chris Mason 已提交
4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457
/*
 * 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.
 */
4458
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
C
Chris Mason 已提交
4459
{
4460
	struct page *page = vmf->page;
4461
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
4462
	struct btrfs_root *root = BTRFS_I(inode)->root;
4463 4464 4465 4466
	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 已提交
4467
	loff_t size;
4468
	int ret;
4469
	u64 page_start;
4470
	u64 page_end;
C
Chris Mason 已提交
4471

J
Josef Bacik 已提交
4472
	ret = btrfs_check_data_free_space(root, inode, PAGE_CACHE_SIZE);
4473 4474 4475 4476 4477
	if (ret) {
		if (ret == -ENOMEM)
			ret = VM_FAULT_OOM;
		else /* -ENOSPC, -EIO, etc */
			ret = VM_FAULT_SIGBUS;
4478
		goto out;
4479
	}
4480

4481
	ret = VM_FAULT_NOPAGE; /* make the VM retry the fault */
4482
again:
C
Chris Mason 已提交
4483 4484
	lock_page(page);
	size = i_size_read(inode);
4485 4486
	page_start = page_offset(page);
	page_end = page_start + PAGE_CACHE_SIZE - 1;
4487

C
Chris Mason 已提交
4488
	if ((page->mapping != inode->i_mapping) ||
4489
	    (page_start >= size)) {
J
Josef Bacik 已提交
4490
		btrfs_free_reserved_data_space(root, inode, PAGE_CACHE_SIZE);
C
Chris Mason 已提交
4491 4492 4493
		/* page got truncated out from underneath us */
		goto out_unlock;
	}
4494 4495 4496 4497 4498
	wait_on_page_writeback(page);

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

4499 4500 4501 4502
	/*
	 * we can't set the delalloc bits if there are pending ordered
	 * extents.  Drop our locks and wait for them to finish
	 */
4503 4504 4505 4506
	ordered = btrfs_lookup_ordered_extent(inode, page_start);
	if (ordered) {
		unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
		unlock_page(page);
4507
		btrfs_start_ordered_extent(inode, ordered, 1);
4508 4509 4510 4511
		btrfs_put_ordered_extent(ordered);
		goto again;
	}

4512
	btrfs_set_extent_delalloc(inode, page_start, page_end);
4513
	ret = 0;
C
Chris Mason 已提交
4514 4515

	/* page is wholly or partially inside EOF */
4516
	if (page_start + PAGE_CACHE_SIZE > size)
4517
		zero_start = size & ~PAGE_CACHE_MASK;
C
Chris Mason 已提交
4518
	else
4519
		zero_start = PAGE_CACHE_SIZE;
C
Chris Mason 已提交
4520

4521 4522 4523 4524 4525 4526
	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);
	}
4527
	ClearPageChecked(page);
4528
	set_page_dirty(page);
4529 4530

	BTRFS_I(inode)->last_trans = root->fs_info->generation + 1;
4531
	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
C
Chris Mason 已提交
4532 4533 4534

out_unlock:
	unlock_page(page);
4535
out:
C
Chris Mason 已提交
4536 4537 4538
	return ret;
}

C
Chris Mason 已提交
4539 4540 4541 4542 4543
static void btrfs_truncate(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;
	struct btrfs_trans_handle *trans;
4544
	unsigned long nr;
4545
	u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
4546 4547 4548 4549 4550 4551 4552

	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 已提交
4553
	btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
C
Chris Mason 已提交
4554 4555

	trans = btrfs_start_transaction(root, 1);
4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576

	/*
	 * setattr is responsible for setting the ordered_data_close flag,
	 * but that is only tested during the last file release.  That
	 * could happen well after the next commit, leaving a great big
	 * window where new writes may get lost if someone chooses to write
	 * to this file after truncating to zero
	 *
	 * The inode doesn't have any dirty data here, and so if we commit
	 * this is a noop.  If someone immediately starts writing to the inode
	 * it is very likely we'll catch some of their writes in this
	 * transaction, and the commit will find this file on the ordered
	 * data list with good things to send down.
	 *
	 * This is a best effort solution, there is still a window where
	 * using truncate to replace the contents of the file will
	 * end up with a zero length file after a crash.
	 */
	if (inode->i_size == 0 && BTRFS_I(inode)->ordered_data_close)
		btrfs_add_ordered_operation(trans, root, inode);

C
Chris Mason 已提交
4577
	btrfs_set_trans_block_group(trans, inode);
4578
	btrfs_i_size_write(inode, inode->i_size);
C
Chris Mason 已提交
4579

4580 4581 4582
	ret = btrfs_orphan_add(trans, inode);
	if (ret)
		goto out;
C
Chris Mason 已提交
4583
	/* FIXME, add redo link to tree so we don't leak on crash */
4584
	ret = btrfs_truncate_inode_items(trans, root, inode, inode->i_size,
4585
				      BTRFS_EXTENT_DATA_KEY);
C
Chris Mason 已提交
4586
	btrfs_update_inode(trans, root, inode);
4587

4588 4589 4590 4591 4592
	ret = btrfs_orphan_del(trans, inode);
	BUG_ON(ret);

out:
	nr = trans->blocks_used;
4593
	ret = btrfs_end_transaction_throttle(trans, root);
C
Chris Mason 已提交
4594
	BUG_ON(ret);
4595
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
4596 4597
}

C
Chris Mason 已提交
4598 4599 4600
/*
 * create a new subvolume directory/inode (helper for the ioctl).
 */
4601 4602 4603
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 已提交
4604 4605
{
	struct inode *inode;
4606
	int error;
4607
	u64 index = 0;
C
Chris Mason 已提交
4608

4609
	inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid,
4610
				new_dirid, alloc_hint, S_IFDIR | 0700, &index);
4611
	if (IS_ERR(inode))
C
Christoph Hellwig 已提交
4612
		return PTR_ERR(inode);
C
Chris Mason 已提交
4613 4614 4615 4616
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;

	inode->i_nlink = 1;
4617
	btrfs_i_size_write(inode, 0);
4618

4619 4620 4621 4622 4623 4624
	error = btrfs_update_inode(trans, new_root, inode);
	if (error)
		return error;

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

C
Chris Mason 已提交
4627 4628 4629
/* helper function for file defrag and space balancing.  This
 * forces readahead on a given range of bytes in an inode
 */
4630
unsigned long btrfs_force_ra(struct address_space *mapping,
4631 4632 4633
			      struct file_ra_state *ra, struct file *file,
			      pgoff_t offset, pgoff_t last_index)
{
4634
	pgoff_t req_size = last_index - offset + 1;
4635 4636 4637 4638 4639

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

C
Chris Mason 已提交
4640 4641 4642 4643 4644 4645 4646
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;
4647
	ei->last_trans = 0;
4648
	ei->logged_trans = 0;
4649
	btrfs_ordered_inode_tree_init(&ei->ordered_tree);
J
Josef Bacik 已提交
4650 4651
	ei->i_acl = BTRFS_ACL_NOT_CACHED;
	ei->i_default_acl = BTRFS_ACL_NOT_CACHED;
4652
	INIT_LIST_HEAD(&ei->i_orphan);
4653
	INIT_LIST_HEAD(&ei->ordered_operations);
C
Chris Mason 已提交
4654 4655 4656 4657 4658
	return &ei->vfs_inode;
}

void btrfs_destroy_inode(struct inode *inode)
{
4659
	struct btrfs_ordered_extent *ordered;
4660 4661
	struct btrfs_root *root = BTRFS_I(inode)->root;

C
Chris Mason 已提交
4662 4663 4664
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);

J
Josef Bacik 已提交
4665 4666 4667 4668 4669 4670 4671
	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);

4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683
	/*
	 * Make sure we're properly removed from the ordered operation
	 * lists.
	 */
	smp_mb();
	if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
		spin_lock(&root->fs_info->ordered_extent_lock);
		list_del_init(&BTRFS_I(inode)->ordered_operations);
		spin_unlock(&root->fs_info->ordered_extent_lock);
	}

	spin_lock(&root->list_lock);
4684 4685 4686 4687 4688
	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();
	}
4689
	spin_unlock(&root->list_lock);
4690

C
Chris Mason 已提交
4691
	while (1) {
4692 4693 4694 4695
		ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
		if (!ordered)
			break;
		else {
C
Chris Mason 已提交
4696 4697 4698 4699
			printk(KERN_ERR "btrfs found ordered "
			       "extent %llu %llu on inode cleanup\n",
			       (unsigned long long)ordered->file_offset,
			       (unsigned long long)ordered->len);
4700 4701 4702 4703 4704
			btrfs_remove_ordered_extent(inode, ordered);
			btrfs_put_ordered_extent(ordered);
			btrfs_put_ordered_extent(ordered);
		}
	}
4705
	inode_tree_del(inode);
4706
	btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
C
Chris Mason 已提交
4707 4708 4709
	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

4710
static void init_once(void *foo)
C
Chris Mason 已提交
4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
	if (btrfs_inode_cachep)
		kmem_cache_destroy(btrfs_inode_cachep);
	if (btrfs_trans_handle_cachep)
		kmem_cache_destroy(btrfs_trans_handle_cachep);
	if (btrfs_transaction_cachep)
		kmem_cache_destroy(btrfs_transaction_cachep);
	if (btrfs_path_cachep)
		kmem_cache_destroy(btrfs_path_cachep);
}

int btrfs_init_cachep(void)
{
4731 4732 4733
	btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
			sizeof(struct btrfs_inode), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
C
Chris Mason 已提交
4734 4735
	if (!btrfs_inode_cachep)
		goto fail;
4736 4737 4738 4739

	btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
			sizeof(struct btrfs_trans_handle), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
4740 4741
	if (!btrfs_trans_handle_cachep)
		goto fail;
4742 4743 4744 4745

	btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
			sizeof(struct btrfs_transaction), 0,
			SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
C
Chris Mason 已提交
4746 4747
	if (!btrfs_transaction_cachep)
		goto fail;
4748 4749 4750 4751

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

C
Chris Mason 已提交
4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765
	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);
4766
	stat->dev = BTRFS_I(inode)->root->anon_super.s_dev;
C
Chris Mason 已提交
4767
	stat->blksize = PAGE_CACHE_SIZE;
4768 4769
	stat->blocks = (inode_get_bytes(inode) +
			BTRFS_I(inode)->delalloc_bytes) >> 9;
C
Chris Mason 已提交
4770 4771 4772
	return 0;
}

C
Chris Mason 已提交
4773 4774
static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
C
Chris Mason 已提交
4775 4776 4777 4778 4779 4780
{
	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;
4781
	u64 index = 0;
C
Chris Mason 已提交
4782 4783
	int ret;

4784 4785 4786 4787 4788
	/* 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 已提交
4789 4790 4791 4792
	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
		return -ENOTEMPTY;
	}
4793

4794 4795 4796 4797 4798 4799
	/* to rename a snapshot or subvolume, we need to juggle the
	 * backrefs.  This isn't coded yet
	 */
	if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
		return -EXDEV;

J
Josef Bacik 已提交
4800
	ret = btrfs_check_metadata_free_space(root);
4801 4802 4803
	if (ret)
		goto out_unlock;

4804 4805 4806 4807 4808 4809 4810 4811 4812 4813
	/*
	 * we're using rename to replace one file with another.
	 * and the replacement file is large.  Start IO on it now so
	 * we don't add too much work to the end of the transaction
	 */
	if (new_inode && old_inode && S_ISREG(old_inode->i_mode) &&
	    new_inode->i_size &&
	    old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
		filemap_flush(old_inode->i_mapping);

C
Chris Mason 已提交
4814
	trans = btrfs_start_transaction(root, 1);
4815

4816 4817 4818 4819 4820 4821 4822 4823 4824
	/*
	 * make sure the inode gets flushed if it is replacing
	 * something.
	 */
	if (new_inode && new_inode->i_size &&
	    old_inode && S_ISREG(old_inode->i_mode)) {
		btrfs_add_ordered_operation(trans, root, old_inode);
	}

4825 4826 4827 4828 4829 4830 4831 4832 4833
	/*
	 * this is an ugly little race, but the rename is required to make
	 * sure that if we crash, the inode is either at the old name
	 * or the new one.  pinning the log transaction lets us make sure
	 * we don't allow a log commit to come in after we unlink the
	 * name but before we add the new name back in.
	 */
	btrfs_pin_log_trans(root);

C
Chris Mason 已提交
4834 4835
	btrfs_set_trans_block_group(trans, new_dir);

4836
	btrfs_inc_nlink(old_dentry->d_inode);
C
Chris Mason 已提交
4837 4838 4839
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
4840

4841 4842 4843
	if (old_dentry->d_parent != new_dentry->d_parent)
		btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);

4844 4845 4846
	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 已提交
4847 4848 4849 4850 4851
	if (ret)
		goto out_fail;

	if (new_inode) {
		new_inode->i_ctime = CURRENT_TIME;
4852 4853 4854 4855
		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 已提交
4856 4857
		if (ret)
			goto out_fail;
4858
		if (new_inode->i_nlink == 0) {
4859
			ret = btrfs_orphan_add(trans, new_dentry->d_inode);
4860 4861 4862
			if (ret)
				goto out_fail;
		}
4863

C
Chris Mason 已提交
4864
	}
4865
	ret = btrfs_set_inode_index(new_dir, &index);
4866 4867 4868
	if (ret)
		goto out_fail;

4869 4870 4871
	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 已提交
4872 4873 4874
	if (ret)
		goto out_fail;

4875 4876
	btrfs_log_new_name(trans, old_inode, old_dir,
				       new_dentry->d_parent);
C
Chris Mason 已提交
4877
out_fail:
4878 4879 4880 4881 4882

	/* this btrfs_end_log_trans just allows the current
	 * log-sub transaction to complete
	 */
	btrfs_end_log_trans(root);
4883
	btrfs_end_transaction_throttle(trans, root);
4884
out_unlock:
C
Chris Mason 已提交
4885 4886 4887
	return ret;
}

C
Chris Mason 已提交
4888 4889 4890 4891
/*
 * some fairly slow code that needs optimization. This walks the list
 * of all the inodes with pending delalloc and forces them to disk.
 */
4892 4893 4894 4895
int btrfs_start_delalloc_inodes(struct btrfs_root *root)
{
	struct list_head *head = &root->fs_info->delalloc_inodes;
	struct btrfs_inode *binode;
4896
	struct inode *inode;
4897

Y
Yan Zheng 已提交
4898 4899 4900
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

4901
	spin_lock(&root->fs_info->delalloc_lock);
C
Chris Mason 已提交
4902
	while (!list_empty(head)) {
4903 4904
		binode = list_entry(head->next, struct btrfs_inode,
				    delalloc_inodes);
4905 4906 4907
		inode = igrab(&binode->vfs_inode);
		if (!inode)
			list_del_init(&binode->delalloc_inodes);
4908
		spin_unlock(&root->fs_info->delalloc_lock);
4909
		if (inode) {
4910
			filemap_flush(inode->i_mapping);
4911 4912 4913
			iput(inode);
		}
		cond_resched();
4914
		spin_lock(&root->fs_info->delalloc_lock);
4915
	}
4916
	spin_unlock(&root->fs_info->delalloc_lock);
4917 4918 4919 4920 4921 4922

	/* 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 已提交
4923
	while (atomic_read(&root->fs_info->nr_async_submits) ||
4924
	      atomic_read(&root->fs_info->async_delalloc_pages)) {
4925
		wait_event(root->fs_info->async_submit_wait,
4926 4927
		   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
		    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
4928 4929
	}
	atomic_dec(&root->fs_info->async_submit_draining);
4930 4931 4932
	return 0;
}

C
Chris Mason 已提交
4933 4934 4935 4936 4937 4938 4939
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;
4940
	struct inode *inode = NULL;
C
Chris Mason 已提交
4941 4942 4943
	int err;
	int drop_inode = 0;
	u64 objectid;
4944
	u64 index = 0 ;
C
Chris Mason 已提交
4945 4946
	int name_len;
	int datasize;
4947
	unsigned long ptr;
C
Chris Mason 已提交
4948
	struct btrfs_file_extent_item *ei;
4949
	struct extent_buffer *leaf;
4950
	unsigned long nr = 0;
C
Chris Mason 已提交
4951 4952 4953 4954

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

J
Josef Bacik 已提交
4956
	err = btrfs_check_metadata_free_space(root);
4957 4958 4959
	if (err)
		goto out_fail;

C
Chris Mason 已提交
4960 4961 4962 4963 4964 4965 4966 4967 4968
	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;
	}

4969
	inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
4970 4971
				dentry->d_name.len,
				dentry->d_parent->d_inode->i_ino, objectid,
4972 4973
				BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
				&index);
C
Chris Mason 已提交
4974 4975 4976 4977
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

J
Jim Owens 已提交
4978
	err = btrfs_init_inode_security(inode, dir);
J
Josef Bacik 已提交
4979 4980 4981 4982 4983
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}

C
Chris Mason 已提交
4984
	btrfs_set_trans_block_group(trans, inode);
4985
	err = btrfs_add_nondir(trans, dentry, inode, 0, index);
C
Chris Mason 已提交
4986 4987 4988 4989
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
C
Chris Mason 已提交
4990
		inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
C
Chris Mason 已提交
4991 4992
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
4993
		BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
C
Chris Mason 已提交
4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008
	}
	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);
5009 5010 5011 5012
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}
5013 5014 5015 5016 5017
	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 已提交
5018
				   BTRFS_FILE_EXTENT_INLINE);
C
Chris Mason 已提交
5019 5020 5021 5022 5023
	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 已提交
5024
	ptr = btrfs_file_extent_inline_start(ei);
5025 5026
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
5027
	btrfs_free_path(path);
5028

C
Chris Mason 已提交
5029 5030
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
C
Chris Mason 已提交
5031
	inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
Y
Yan Zheng 已提交
5032
	inode_set_bytes(inode, name_len);
5033
	btrfs_i_size_write(inode, name_len - 1);
5034 5035 5036
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
5037 5038

out_unlock:
5039
	nr = trans->blocks_used;
5040
	btrfs_end_transaction_throttle(trans, root);
5041
out_fail:
C
Chris Mason 已提交
5042 5043 5044 5045
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
5046
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
5047 5048
	return err;
}
5049

5050 5051
static int prealloc_file_range(struct btrfs_trans_handle *trans,
			       struct inode *inode, u64 start, u64 end,
5052
			       u64 locked_end, u64 alloc_hint, int mode)
Y
Yan Zheng 已提交
5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key ins;
	u64 alloc_size;
	u64 cur_offset = start;
	u64 num_bytes = end - start;
	int ret = 0;

	while (num_bytes > 0) {
		alloc_size = min(num_bytes, root->fs_info->max_extent);
		ret = btrfs_reserve_extent(trans, root, alloc_size,
					   root->sectorsize, 0, alloc_hint,
					   (u64)-1, &ins, 1);
		if (ret) {
			WARN_ON(1);
			goto out;
		}
		ret = insert_reserved_file_extent(trans, inode,
						  cur_offset, ins.objectid,
						  ins.offset, ins.offset,
5073 5074
						  ins.offset, locked_end,
						  0, 0, 0,
Y
Yan Zheng 已提交
5075 5076 5077 5078 5079 5080 5081 5082 5083
						  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;
5084
		BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
Y
Yan Zheng 已提交
5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102
		if (!(mode & FALLOC_FL_KEEP_SIZE) &&
		    cur_offset > i_size_read(inode))
			btrfs_i_size_write(inode, cur_offset);
		ret = btrfs_update_inode(trans, root, inode);
		BUG_ON(ret);
	}

	return ret;
}

static long btrfs_fallocate(struct inode *inode, int mode,
			    loff_t offset, loff_t len)
{
	u64 cur_offset;
	u64 last_byte;
	u64 alloc_start;
	u64 alloc_end;
	u64 alloc_hint = 0;
5103
	u64 locked_end;
Y
Yan Zheng 已提交
5104 5105
	u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
	struct extent_map *em;
5106
	struct btrfs_trans_handle *trans;
5107
	struct btrfs_root *root;
Y
Yan Zheng 已提交
5108 5109 5110 5111 5112
	int ret;

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

5113 5114 5115 5116 5117 5118
	/*
	 * wait for ordered IO before we have any locks.  We'll loop again
	 * below with the locks held.
	 */
	btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);

Y
Yan Zheng 已提交
5119 5120 5121 5122 5123 5124 5125
	mutex_lock(&inode->i_mutex);
	if (alloc_start > inode->i_size) {
		ret = btrfs_cont_expand(inode, alloc_start);
		if (ret)
			goto out;
	}

5126 5127 5128 5129 5130 5131 5132
	root = BTRFS_I(inode)->root;

	ret = btrfs_check_data_free_space(root, inode,
					  alloc_end - alloc_start);
	if (ret)
		goto out;

5133
	locked_end = alloc_end - 1;
Y
Yan Zheng 已提交
5134 5135
	while (1) {
		struct btrfs_ordered_extent *ordered;
5136 5137 5138 5139

		trans = btrfs_start_transaction(BTRFS_I(inode)->root, 1);
		if (!trans) {
			ret = -EIO;
5140
			goto out_free;
5141 5142 5143 5144 5145
		}

		/* the extent lock is ordered inside the running
		 * transaction
		 */
5146 5147
		lock_extent(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
			    GFP_NOFS);
Y
Yan Zheng 已提交
5148 5149 5150 5151 5152 5153 5154
		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,
5155
				      alloc_start, locked_end, GFP_NOFS);
5156 5157 5158 5159 5160 5161
			btrfs_end_transaction(trans, BTRFS_I(inode)->root);

			/*
			 * we can't wait on the range with the transaction
			 * running or with the extent lock held
			 */
Y
Yan Zheng 已提交
5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178
			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) {
5179
			ret = prealloc_file_range(trans, inode, cur_offset,
5180 5181
					last_byte, locked_end + 1,
					alloc_hint, mode);
Y
Yan Zheng 已提交
5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196
			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;
		}
	}
5197
	unlock_extent(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
Y
Yan Zheng 已提交
5198
		      GFP_NOFS);
5199 5200

	btrfs_end_transaction(trans, BTRFS_I(inode)->root);
5201 5202
out_free:
	btrfs_free_reserved_data_space(root, inode, alloc_end - alloc_start);
Y
Yan Zheng 已提交
5203 5204 5205 5206 5207
out:
	mutex_unlock(&inode->i_mutex);
	return ret;
}

5208 5209 5210 5211 5212
static int btrfs_set_page_dirty(struct page *page)
{
	return __set_page_dirty_nobuffers(page);
}

5213
static int btrfs_permission(struct inode *inode, int mask)
Y
Yan 已提交
5214
{
5215
	if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE))
Y
Yan 已提交
5216
		return -EACCES;
J
Josef Bacik 已提交
5217
	return generic_permission(inode, mask, btrfs_check_acl);
Y
Yan 已提交
5218
}
C
Chris Mason 已提交
5219 5220

static struct inode_operations btrfs_dir_inode_operations = {
5221
	.getattr	= btrfs_getattr,
C
Chris Mason 已提交
5222 5223 5224 5225 5226 5227 5228 5229 5230
	.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 已提交
5231
	.mknod		= btrfs_mknod,
5232 5233
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5234
	.listxattr	= btrfs_listxattr,
5235
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
5236
	.permission	= btrfs_permission,
C
Chris Mason 已提交
5237 5238 5239
};
static struct inode_operations btrfs_dir_ro_inode_operations = {
	.lookup		= btrfs_lookup,
Y
Yan 已提交
5240
	.permission	= btrfs_permission,
C
Chris Mason 已提交
5241 5242 5243 5244
};
static struct file_operations btrfs_dir_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
5245
	.readdir	= btrfs_real_readdir,
C
Christoph Hellwig 已提交
5246
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
5247
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
5248
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
5249
#endif
S
Sage Weil 已提交
5250
	.release        = btrfs_release_file,
5251
	.fsync		= btrfs_sync_file,
C
Chris Mason 已提交
5252 5253
};

5254
static struct extent_io_ops btrfs_extent_io_ops = {
5255
	.fill_delalloc = run_delalloc_range,
5256
	.submit_bio_hook = btrfs_submit_bio_hook,
5257
	.merge_bio_hook = btrfs_merge_bio_hook,
5258
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
5259
	.writepage_end_io_hook = btrfs_writepage_end_io_hook,
5260
	.writepage_start_hook = btrfs_writepage_start_hook,
5261
	.readpage_io_failed_hook = btrfs_io_failed_hook,
C
Chris Mason 已提交
5262 5263
	.set_bit_hook = btrfs_set_bit_hook,
	.clear_bit_hook = btrfs_clear_bit_hook,
5264 5265
};

5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277
/*
 * btrfs doesn't support the bmap operation because swapfiles
 * use bmap to make a mapping of extents in the file.  They assume
 * these extents won't change over the life of the file and they
 * use the bmap result to do IO directly to the drive.
 *
 * the btrfs bmap call would return logical addresses that aren't
 * suitable for IO and they also will change frequently as COW
 * operations happen.  So, swapfile + btrfs == corruption.
 *
 * For now we're avoiding this by dropping bmap.
 */
C
Chris Mason 已提交
5278 5279 5280
static struct address_space_operations btrfs_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
5281
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
5282
	.readpages	= btrfs_readpages,
C
Chris Mason 已提交
5283
	.sync_page	= block_sync_page,
5284
	.direct_IO	= btrfs_direct_IO,
5285 5286
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
5287
	.set_page_dirty	= btrfs_set_page_dirty,
C
Chris Mason 已提交
5288 5289 5290 5291 5292
};

static struct address_space_operations btrfs_symlink_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
5293 5294
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
5295 5296 5297 5298 5299 5300
};

static struct inode_operations btrfs_file_inode_operations = {
	.truncate	= btrfs_truncate,
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
5301 5302
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5303
	.listxattr      = btrfs_listxattr,
5304
	.removexattr	= btrfs_removexattr,
Y
Yan 已提交
5305
	.permission	= btrfs_permission,
Y
Yan Zheng 已提交
5306
	.fallocate	= btrfs_fallocate,
Y
Yehuda Sadeh 已提交
5307
	.fiemap		= btrfs_fiemap,
C
Chris Mason 已提交
5308
};
J
Josef Bacik 已提交
5309 5310 5311
static struct inode_operations btrfs_special_inode_operations = {
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
Y
Yan 已提交
5312
	.permission	= btrfs_permission,
5313 5314
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
J
Josef Bacik 已提交
5315
	.listxattr	= btrfs_listxattr,
5316
	.removexattr	= btrfs_removexattr,
J
Josef Bacik 已提交
5317
};
C
Chris Mason 已提交
5318 5319 5320 5321
static struct inode_operations btrfs_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
Y
Yan 已提交
5322
	.permission	= btrfs_permission,
J
Jim Owens 已提交
5323 5324 5325 5326
	.setxattr	= btrfs_setxattr,
	.getxattr	= btrfs_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= btrfs_removexattr,
C
Chris Mason 已提交
5327
};