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

C
Chris Mason 已提交
19 20 21 22 23 24 25 26 27 28 29 30 31
#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>
32
#include <linux/version.h>
C
Chris Mason 已提交
33 34 35 36 37 38
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"
39
#include "compat.h"
C
Chris Mason 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83


static int btrfs_copy_from_user(loff_t pos, int num_pages, int write_bytes,
				struct page **prepared_pages,
				const char __user * buf)
{
	long page_fault = 0;
	int i;
	int offset = pos & (PAGE_CACHE_SIZE - 1);

	for (i = 0; i < num_pages && write_bytes > 0; i++, offset = 0) {
		size_t count = min_t(size_t,
				     PAGE_CACHE_SIZE - offset, write_bytes);
		struct page *page = prepared_pages[i];
		fault_in_pages_readable(buf, count);

		/* Copy data from userspace to the current page */
		kmap(page);
		page_fault = __copy_from_user(page_address(page) + offset,
					      buf, count);
		/* Flush processor's dcache for this page */
		flush_dcache_page(page);
		kunmap(page);
		buf += count;
		write_bytes -= count;

		if (page_fault)
			break;
	}
	return page_fault ? -EFAULT : 0;
}

static void btrfs_drop_pages(struct page **pages, size_t num_pages)
{
	size_t i;
	for (i = 0; i < num_pages; i++) {
		if (!pages[i])
			break;
		unlock_page(pages[i]);
		mark_page_accessed(pages[i]);
		page_cache_release(pages[i]);
	}
}

84
static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
85
				struct btrfs_root *root, struct inode *inode,
86 87 88
				u64 offset, size_t size,
				struct page **pages, size_t page_offset,
				int num_pages)
89 90 91
{
	struct btrfs_key key;
	struct btrfs_path *path;
92 93 94
	struct extent_buffer *leaf;
	char *kaddr;
	unsigned long ptr;
95
	struct btrfs_file_extent_item *ei;
96
	struct page *page;
97 98 99
	u32 datasize;
	int err = 0;
	int ret;
100 101
	int i;
	ssize_t cur_size;
102 103 104 105 106 107 108 109 110 111 112

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

	btrfs_set_trans_block_group(trans, inode);

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

113 114
	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
	if (ret < 0) {
115 116 117
		err = ret;
		goto fail;
	}
118
	if (ret == 1) {
119 120 121 122 123
		struct btrfs_key found_key;

		if (path->slots[0] == 0)
			goto insert;

124 125
		path->slots[0]--;
		leaf = path->nodes[0];
126 127 128 129 130 131 132
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

		if (found_key.objectid != inode->i_ino)
			goto insert;

		if (found_key.type != BTRFS_EXTENT_DATA_KEY)
			goto insert;
133 134 135 136 137 138 139 140 141 142 143 144
		ei = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);

		if (btrfs_file_extent_type(leaf, ei) !=
		    BTRFS_FILE_EXTENT_INLINE) {
			goto insert;
		}
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
		ret = 0;
	}
	if (ret == 0) {
		u32 found_size;
145
		u64 found_end;
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160

		leaf = path->nodes[0];
		ei = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_file_extent_item);

		if (btrfs_file_extent_type(leaf, ei) !=
		    BTRFS_FILE_EXTENT_INLINE) {
			err = ret;
			btrfs_print_leaf(root, leaf);
			printk("found wasn't inline offset %Lu inode %lu\n",
			       offset, inode->i_ino);
			goto fail;
		}
		found_size = btrfs_file_extent_inline_len(leaf,
					  btrfs_item_nr(leaf, path->slots[0]));
161
		found_end = key.offset + found_size;
162

163
		if (found_end < offset + size) {
164 165
			btrfs_release_path(root, path);
			ret = btrfs_search_slot(trans, root, &key, path,
166
						offset + size - found_end, 1);
167
			BUG_ON(ret != 0);
168

169
			ret = btrfs_extend_item(trans, root, path,
170
						offset + size - found_end);
171 172 173 174 175 176 177
			if (ret) {
				err = ret;
				goto fail;
			}
			leaf = path->nodes[0];
			ei = btrfs_item_ptr(leaf, path->slots[0],
					    struct btrfs_file_extent_item);
C
Chris Mason 已提交
178
			inode->i_blocks += (offset + size - found_end) >> 9;
179
		}
180 181 182 183
		if (found_end < offset) {
			ptr = btrfs_file_extent_inline_start(ei) + found_size;
			memset_extent_buffer(leaf, 0, ptr, offset - found_end);
		}
184 185 186
	} else {
insert:
		btrfs_release_path(root, path);
187
		datasize = offset + size - key.offset;
C
Chris Mason 已提交
188
		inode->i_blocks += datasize >> 9;
189
		datasize = btrfs_file_extent_calc_inline_size(datasize);
190 191 192 193 194 195 196 197 198 199 200 201 202
		ret = btrfs_insert_empty_item(trans, root, path, &key,
					      datasize);
		if (ret) {
			err = ret;
			printk("got bad ret %d\n", 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);
	}
203
	ptr = btrfs_file_extent_inline_start(ei) + offset - key.offset;
204 205 206 207 208 209

	cur_size = size;
	i = 0;
	while (size > 0) {
		page = pages[i];
		kaddr = kmap_atomic(page, KM_USER0);
J
Jens Axboe 已提交
210
		cur_size = min_t(size_t, PAGE_CACHE_SIZE - page_offset, size);
211 212 213 214 215 216 217 218 219 220
		write_extent_buffer(leaf, kaddr + page_offset, ptr, cur_size);
		kunmap_atomic(kaddr, KM_USER0);
		page_offset = 0;
		ptr += cur_size;
		size -= cur_size;
		if (i >= num_pages) {
			printk("i %d num_pages %d\n", i, num_pages);
		}
		i++;
	}
221
	btrfs_mark_buffer_dirty(leaf);
222 223 224 225 226
fail:
	btrfs_free_path(path);
	return err;
}

227
static int noinline dirty_and_release_pages(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
228 229 230 231 232 233 234 235
				   struct btrfs_root *root,
				   struct file *file,
				   struct page **pages,
				   size_t num_pages,
				   loff_t pos,
				   size_t write_bytes)
{
	int err = 0;
236
	int i;
237
	struct inode *inode = fdentry(file)->d_inode;
238
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
239 240
	u64 hint_byte;
	u64 num_bytes;
241 242 243
	u64 start_pos;
	u64 end_of_last_block;
	u64 end_pos = pos + write_bytes;
244
	u64 inline_size;
245
	loff_t isize = i_size_read(inode);
C
Chris Mason 已提交
246

247
	start_pos = pos & ~((u64)root->sectorsize - 1);
248 249
	num_bytes = (write_bytes + pos - start_pos +
		    root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
C
Chris Mason 已提交
250

251 252
	end_of_last_block = start_pos + num_bytes - 1;

253
	lock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
254 255 256 257 258 259
	trans = btrfs_start_transaction(root, 1);
	if (!trans) {
		err = -ENOMEM;
		goto out_unlock;
	}
	btrfs_set_trans_block_group(trans, inode);
260
	hint_byte = 0;
261 262

	if ((end_of_last_block & 4095) == 0) {
263
		printk("strange end of last %Lu %zu %Lu\n", start_pos, write_bytes, end_of_last_block);
264
	}
265
	set_extent_uptodate(io_tree, start_pos, end_of_last_block, GFP_NOFS);
266 267 268

	/* FIXME...EIEIO, ENOSPC and more */
	/* insert any holes we need to create */
269
	if (isize < start_pos) {
270 271
		u64 last_pos_in_file;
		u64 hole_size;
272
		u64 mask = root->sectorsize - 1;
273
		last_pos_in_file = (isize + mask) & ~mask;
274
		hole_size = (start_pos - last_pos_in_file + mask) & ~mask;
275 276 277
		if (hole_size > 0) {
			btrfs_wait_ordered_range(inode, last_pos_in_file,
						 last_pos_in_file + hole_size);
C
Chris Mason 已提交
278 279 280
			err = btrfs_drop_extents(trans, root, inode,
						 last_pos_in_file,
						 last_pos_in_file + hole_size,
281
						 last_pos_in_file,
282
						 &hint_byte);
C
Chris Mason 已提交
283 284 285
			if (err)
				goto failed;

286 287 288
			err = btrfs_insert_file_extent(trans, root,
						       inode->i_ino,
						       last_pos_in_file,
S
Sage Weil 已提交
289
						       0, 0, hole_size, 0);
290 291
			btrfs_drop_extent_cache(inode, last_pos_in_file,
					last_pos_in_file + hole_size -1);
292
			btrfs_check_file(root, inode);
293 294
		}
		if (err)
C
Chris Mason 已提交
295
			goto failed;
296 297 298 299 300 301
	}

	/*
	 * either allocate an extent for the new bytes or setup the key
	 * to show we are doing inline data in the extent
	 */
302 303
	inline_size = end_pos;
	if (isize >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
304 305
	    inline_size > root->fs_info->max_inline ||
	    (inline_size & (root->sectorsize -1)) == 0 ||
306
	    inline_size >= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
307 308 309 310 311 312
		/* check for reserved extents on each page, we don't want
		 * to reset the delalloc bit on things that already have
		 * extents reserved.
		 */
		set_extent_delalloc(io_tree, start_pos,
				    end_of_last_block, GFP_NOFS);
313 314 315
		for (i = 0; i < num_pages; i++) {
			struct page *p = pages[i];
			SetPageUptodate(p);
316
			ClearPageChecked(p);
317
			set_page_dirty(p);
C
Chris Mason 已提交
318
		}
319
	} else {
320
		u64 aligned_end;
321
		/* step one, delete the existing extents in this range */
322 323
		aligned_end = (pos + write_bytes + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
C
Chris Mason 已提交
324
		err = btrfs_drop_extents(trans, root, inode, start_pos,
325
					 aligned_end, aligned_end, &hint_byte);
C
Chris Mason 已提交
326 327
		if (err)
			goto failed;
328 329 330
		if (isize > inline_size)
			inline_size = min_t(u64, isize, aligned_end);
		inline_size -= start_pos;
331
		err = insert_inline_extent(trans, root, inode, start_pos,
332
					   inline_size, pages, 0, num_pages);
333
		btrfs_drop_extent_cache(inode, start_pos, aligned_end - 1);
334 335 336 337 338
		BUG_ON(err);
	}
	if (end_pos > isize) {
		i_size_write(inode, end_pos);
		btrfs_update_inode(trans, root, inode);
C
Chris Mason 已提交
339 340
	}
failed:
341 342
	err = btrfs_end_transaction(trans, root);
out_unlock:
343
	unlock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
C
Chris Mason 已提交
344 345 346
	return err;
}

347 348 349
int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end)
{
	struct extent_map *em;
350 351
	struct extent_map *split = NULL;
	struct extent_map *split2 = NULL;
352
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
353
	struct extent_map *tmp;
354
	u64 len = end - start + 1;
355
	u64 next_start;
356 357
	int ret;
	int testend = 1;
358

359
	WARN_ON(end < start);
360
	if (end == (u64)-1) {
361
		len = (u64)-1;
362 363
		testend = 0;
	}
364
	while(1) {
365 366 367 368 369
		if (!split)
			split = alloc_extent_map(GFP_NOFS);
		if (!split2)
			split2 = alloc_extent_map(GFP_NOFS);

370
		spin_lock(&em_tree->lock);
371
		em = lookup_extent_mapping(em_tree, start, len);
372 373
		if (!em) {
			spin_unlock(&em_tree->lock);
374
			break;
375
		}
376 377
		tmp = rb_entry(&em->rb_node, struct extent_map, rb_node);
		next_start = tmp->start;
378
		remove_extent_mapping(em_tree, em);
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408

		if (em->block_start < EXTENT_MAP_LAST_BYTE &&
		    em->start < start) {
			split->start = em->start;
			split->len = start - em->start;
			split->block_start = em->block_start;
			split->bdev = em->bdev;
			split->flags = em->flags;
			ret = add_extent_mapping(em_tree, split);
			BUG_ON(ret);
			free_extent_map(split);
			split = split2;
			split2 = NULL;
		}
		if (em->block_start < EXTENT_MAP_LAST_BYTE &&
		    testend && em->start + em->len > start + len) {
			u64 diff = start + len - em->start;

			split->start = start + len;
			split->len = em->start + em->len - (start + len);
			split->bdev = em->bdev;
			split->flags = em->flags;

			split->block_start = em->block_start + diff;

			ret = add_extent_mapping(em_tree, split);
			BUG_ON(ret);
			free_extent_map(split);
			split = NULL;
		}
409 410
		spin_unlock(&em_tree->lock);

411 412 413 414 415
		/* once for us */
		free_extent_map(em);
		/* once for the tree*/
		free_extent_map(em);
	}
416 417 418 419
	if (split)
		free_extent_map(split);
	if (split2)
		free_extent_map(split2);
420 421 422
	return 0;
}

423 424 425 426 427 428 429 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
int btrfs_check_file(struct btrfs_root *root, struct inode *inode)
{
	return 0;
#if 0
	struct btrfs_path *path;
	struct btrfs_key found_key;
	struct extent_buffer *leaf;
	struct btrfs_file_extent_item *extent;
	u64 last_offset = 0;
	int nritems;
	int slot;
	int found_type;
	int ret;
	int err = 0;
	u64 extent_end = 0;

	path = btrfs_alloc_path();
	ret = btrfs_lookup_file_extent(NULL, root, path, inode->i_ino,
				       last_offset, 0);
	while(1) {
		nritems = btrfs_header_nritems(path->nodes[0]);
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(root, path);
			if (ret)
				goto out;
			nritems = btrfs_header_nritems(path->nodes[0]);
		}
		slot = path->slots[0];
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
		if (found_key.objectid != inode->i_ino)
			break;
		if (found_key.type != BTRFS_EXTENT_DATA_KEY)
			goto out;

C
Chris Mason 已提交
458
		if (found_key.offset < last_offset) {
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
			WARN_ON(1);
			btrfs_print_leaf(root, leaf);
			printk("inode %lu found offset %Lu expected %Lu\n",
			       inode->i_ino, found_key.offset, last_offset);
			err = 1;
			goto out;
		}
		extent = btrfs_item_ptr(leaf, slot,
					struct btrfs_file_extent_item);
		found_type = btrfs_file_extent_type(leaf, extent);
		if (found_type == BTRFS_FILE_EXTENT_REG) {
			extent_end = found_key.offset +
			     btrfs_file_extent_num_bytes(leaf, extent);
		} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
			struct btrfs_item *item;
			item = btrfs_item_nr(leaf, slot);
			extent_end = found_key.offset +
			     btrfs_file_extent_inline_len(leaf, item);
			extent_end = (extent_end + root->sectorsize - 1) &
				~((u64)root->sectorsize -1 );
		}
		last_offset = extent_end;
		path->slots[0]++;
	}
C
Chris Mason 已提交
483
	if (0 && last_offset < inode->i_size) {
484 485 486 487 488 489 490 491 492 493 494 495 496
		WARN_ON(1);
		btrfs_print_leaf(root, leaf);
		printk("inode %lu found offset %Lu size %Lu\n", inode->i_ino,
		       last_offset, inode->i_size);
		err = 1;

	}
out:
	btrfs_free_path(path);
	return err;
#endif
}

C
Chris Mason 已提交
497 498 499 500 501 502 503 504 505 506 507
/*
 * this is very complex, but the basic idea is to drop all extents
 * in the range start - end.  hint_block is filled in with a block number
 * that would be a good hint to the block allocator for this file.
 *
 * If an extent intersects the range but is not entirely inside the range
 * it is either truncated or split.  Anything entirely inside the range
 * is deleted from the tree.
 */
int btrfs_drop_extents(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root, struct inode *inode,
508
		       u64 start, u64 end, u64 inline_limit, u64 *hint_byte)
C
Chris Mason 已提交
509
{
510 511
	u64 extent_end = 0;
	u64 search_start = start;
512
	struct extent_buffer *leaf;
C
Chris Mason 已提交
513 514
	struct btrfs_file_extent_item *extent;
	struct btrfs_path *path;
515 516 517 518
	struct btrfs_key key;
	struct btrfs_file_extent_item old;
	int keep;
	int slot;
C
Chris Mason 已提交
519 520 521 522
	int bookend;
	int found_type;
	int found_extent;
	int found_inline;
C
Chris Mason 已提交
523
	int recow;
524
	int ret;
C
Chris Mason 已提交
525

526 527
	btrfs_drop_extent_cache(inode, start, end - 1);

C
Chris Mason 已提交
528 529 530 531
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	while(1) {
C
Chris Mason 已提交
532
		recow = 0;
C
Chris Mason 已提交
533 534 535 536 537 538 539 540 541 542 543 544
		btrfs_release_path(root, path);
		ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
					       search_start, -1);
		if (ret < 0)
			goto out;
		if (ret > 0) {
			if (path->slots[0] == 0) {
				ret = 0;
				goto out;
			}
			path->slots[0]--;
		}
545
next_slot:
C
Chris Mason 已提交
546 547 548 549 550
		keep = 0;
		bookend = 0;
		found_extent = 0;
		found_inline = 0;
		extent = NULL;
551
		leaf = path->nodes[0];
C
Chris Mason 已提交
552
		slot = path->slots[0];
553
		ret = 0;
554
		btrfs_item_key_to_cpu(leaf, &key, slot);
555 556
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY &&
		    key.offset >= end) {
C
Chris Mason 已提交
557 558
			goto out;
		}
559 560
		if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
		    key.objectid != inode->i_ino) {
C
Chris Mason 已提交
561 562
			goto out;
		}
C
Chris Mason 已提交
563 564 565 566
		if (recow) {
			search_start = key.offset;
			continue;
		}
567 568 569
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
			extent = btrfs_item_ptr(leaf, slot,
						struct btrfs_file_extent_item);
570
			found_type = btrfs_file_extent_type(leaf, extent);
571
			if (found_type == BTRFS_FILE_EXTENT_REG) {
572 573 574 575 576 577
				extent_end =
				     btrfs_file_extent_disk_bytenr(leaf,
								   extent);
				if (extent_end)
					*hint_byte = extent_end;

578
				extent_end = key.offset +
579
				     btrfs_file_extent_num_bytes(leaf, extent);
580 581
				found_extent = 1;
			} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
582 583
				struct btrfs_item *item;
				item = btrfs_item_nr(leaf, slot);
584 585
				found_inline = 1;
				extent_end = key.offset +
586
				     btrfs_file_extent_inline_len(leaf, item);
587 588 589
			}
		} else {
			extent_end = search_start;
C
Chris Mason 已提交
590 591 592
		}

		/* we found nothing we can drop */
593 594 595 596
		if ((!found_extent && !found_inline) ||
		    search_start >= extent_end) {
			int nextret;
			u32 nritems;
597
			nritems = btrfs_header_nritems(leaf);
598 599 600 601
			if (slot >= nritems - 1) {
				nextret = btrfs_next_leaf(root, path);
				if (nextret)
					goto out;
C
Chris Mason 已提交
602
				recow = 1;
603 604 605 606
			} else {
				path->slots[0]++;
			}
			goto next_slot;
C
Chris Mason 已提交
607 608 609
		}

		if (found_inline) {
610
			u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
611 612 613
			search_start = (extent_end + mask) & ~mask;
		} else
			search_start = extent_end;
Y
Yan 已提交
614
		if (end <= extent_end && start >= key.offset && found_inline) {
615
			*hint_byte = EXTENT_MAP_INLINE;
Y
Yan 已提交
616
			continue;
617
		}
C
Chris Mason 已提交
618 619
		if (end < extent_end && end >= key.offset) {
			if (found_extent) {
620 621 622 623
				u64 disk_bytenr =
				    btrfs_file_extent_disk_bytenr(leaf, extent);
				u64 disk_num_bytes =
				    btrfs_file_extent_disk_num_bytes(leaf,
624 625 626 627
								      extent);
				read_extent_buffer(leaf, &old,
						   (unsigned long)extent,
						   sizeof(old));
628
				if (disk_bytenr != 0) {
C
Chris Mason 已提交
629
					ret = btrfs_inc_extent_ref(trans, root,
630 631 632 633
					         disk_bytenr, disk_num_bytes,
						 root->root_key.objectid,
						 trans->transid,
						 key.objectid, end);
C
Chris Mason 已提交
634 635 636
					BUG_ON(ret);
				}
			}
637
			bookend = 1;
638
			if (found_inline && start <= key.offset)
639
				keep = 1;
C
Chris Mason 已提交
640 641 642 643 644 645
		}
		/* truncate existing extent */
		if (start > key.offset) {
			u64 new_num;
			u64 old_num;
			keep = 1;
646
			WARN_ON(start & (root->sectorsize - 1));
C
Chris Mason 已提交
647
			if (found_extent) {
648 649 650 651 652 653 654 655
				new_num = start - key.offset;
				old_num = btrfs_file_extent_num_bytes(leaf,
								      extent);
				*hint_byte =
					btrfs_file_extent_disk_bytenr(leaf,
								      extent);
				if (btrfs_file_extent_disk_bytenr(leaf,
								  extent)) {
C
Chris Mason 已提交
656
					dec_i_blocks(inode, old_num - new_num);
C
Chris Mason 已提交
657
				}
658 659
				btrfs_set_file_extent_num_bytes(leaf, extent,
								new_num);
660
				btrfs_mark_buffer_dirty(leaf);
661 662 663
			} else if (key.offset < inline_limit &&
				   (end > extent_end) &&
				   (inline_limit < extent_end)) {
664 665
				u32 new_size;
				new_size = btrfs_file_extent_calc_inline_size(
666
						   inline_limit - key.offset);
C
Chris Mason 已提交
667 668
				dec_i_blocks(inode, (extent_end - key.offset) -
					(inline_limit - key.offset));
669
				btrfs_truncate_item(trans, root, path,
670
						    new_size, 1);
C
Chris Mason 已提交
671 672 673 674
			}
		}
		/* delete the entire extent */
		if (!keep) {
675 676 677
			u64 disk_bytenr = 0;
			u64 disk_num_bytes = 0;
			u64 extent_num_bytes = 0;
678
			u64 root_gen;
679
			u64 root_owner;
680

681 682
			root_gen = btrfs_header_generation(leaf);
			root_owner = btrfs_header_owner(leaf);
C
Chris Mason 已提交
683
			if (found_extent) {
684 685
				disk_bytenr =
				      btrfs_file_extent_disk_bytenr(leaf,
686
								     extent);
687 688
				disk_num_bytes =
				      btrfs_file_extent_disk_num_bytes(leaf,
689
								       extent);
690 691 692 693 694
				extent_num_bytes =
				      btrfs_file_extent_num_bytes(leaf, extent);
				*hint_byte =
					btrfs_file_extent_disk_bytenr(leaf,
								      extent);
C
Chris Mason 已提交
695 696
			}
			ret = btrfs_del_item(trans, root, path);
697
			/* TODO update progress marker and return */
C
Chris Mason 已提交
698 699 700
			BUG_ON(ret);
			btrfs_release_path(root, path);
			extent = NULL;
701
			if (found_extent && disk_bytenr != 0) {
C
Chris Mason 已提交
702
				dec_i_blocks(inode, extent_num_bytes);
C
Chris Mason 已提交
703
				ret = btrfs_free_extent(trans, root,
704 705
						disk_bytenr,
						disk_num_bytes,
706
						root_owner,
707 708
						root_gen, inode->i_ino,
						key.offset, 0);
C
Chris Mason 已提交
709 710 711 712 713 714 715 716 717 718
			}

			BUG_ON(ret);
			if (!bookend && search_start >= end) {
				ret = 0;
				goto out;
			}
			if (!bookend)
				continue;
		}
719
		if (bookend && found_inline && start <= key.offset) {
720 721
			u32 new_size;
			new_size = btrfs_file_extent_calc_inline_size(
722
						   extent_end - end);
C
Chris Mason 已提交
723 724
			dec_i_blocks(inode, (extent_end - key.offset) -
					(extent_end - end));
725 726
			btrfs_truncate_item(trans, root, path, new_size, 0);
		}
C
Chris Mason 已提交
727 728 729 730 731 732 733 734 735
		/* create bookend, splitting the extent in two */
		if (bookend && found_extent) {
			struct btrfs_key ins;
			ins.objectid = inode->i_ino;
			ins.offset = end;
			btrfs_set_key_type(&ins, BTRFS_EXTENT_DATA_KEY);
			btrfs_release_path(root, path);
			ret = btrfs_insert_empty_item(trans, root, path, &ins,
						      sizeof(*extent));
736

737
			leaf = path->nodes[0];
738
			if (ret) {
739 740
				btrfs_print_leaf(root, leaf);
				printk("got %d on inserting %Lu %u %Lu start %Lu end %Lu found %Lu %Lu keep was %d\n", ret , ins.objectid, ins.type, ins.offset, start, end, key.offset, extent_end, keep);
741
			}
C
Chris Mason 已提交
742
			BUG_ON(ret);
743 744 745 746 747 748
			extent = btrfs_item_ptr(leaf, path->slots[0],
						struct btrfs_file_extent_item);
			write_extent_buffer(leaf, &old,
					    (unsigned long)extent, sizeof(old));

			btrfs_set_file_extent_offset(leaf, extent,
749 750 751 752 753
				    le64_to_cpu(old.offset) + end - key.offset);
			WARN_ON(le64_to_cpu(old.num_bytes) <
				(extent_end - end));
			btrfs_set_file_extent_num_bytes(leaf, extent,
							extent_end - end);
754
			btrfs_set_file_extent_type(leaf, extent,
C
Chris Mason 已提交
755
						   BTRFS_FILE_EXTENT_REG);
756

C
Chris Mason 已提交
757
			btrfs_mark_buffer_dirty(path->nodes[0]);
758
			if (le64_to_cpu(old.disk_bytenr) != 0) {
C
Chris Mason 已提交
759
				inode->i_blocks +=
760 761
				      btrfs_file_extent_num_bytes(leaf,
								  extent) >> 9;
C
Chris Mason 已提交
762 763 764 765 766 767 768
			}
			ret = 0;
			goto out;
		}
	}
out:
	btrfs_free_path(path);
C
Chris Mason 已提交
769
	btrfs_check_file(root, inode);
C
Chris Mason 已提交
770 771 772 773 774 775
	return ret;
}

/*
 * this gets pages into the page cache and locks them down
 */
776 777 778 779
static int prepare_pages(struct btrfs_root *root, struct file *file,
			 struct page **pages, size_t num_pages,
			 loff_t pos, unsigned long first_index,
			 unsigned long last_index, size_t write_bytes)
C
Chris Mason 已提交
780 781 782
{
	int i;
	unsigned long index = pos >> PAGE_CACHE_SHIFT;
783
	struct inode *inode = fdentry(file)->d_inode;
C
Chris Mason 已提交
784
	int err = 0;
785
	u64 start_pos;
786
	u64 last_pos;
787

788
	start_pos = pos & ~((u64)root->sectorsize - 1);
789
	last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT;
C
Chris Mason 已提交
790 791

	memset(pages, 0, num_pages * sizeof(struct page *));
792
again:
C
Chris Mason 已提交
793 794 795 796
	for (i = 0; i < num_pages; i++) {
		pages[i] = grab_cache_page(inode->i_mapping, index + i);
		if (!pages[i]) {
			err = -ENOMEM;
797
			BUG_ON(1);
C
Chris Mason 已提交
798
		}
C
Chris Mason 已提交
799
		wait_on_page_writeback(pages[i]);
C
Chris Mason 已提交
800
	}
801
	if (start_pos < inode->i_size) {
802
		struct btrfs_ordered_extent *ordered;
803 804
		lock_extent(&BTRFS_I(inode)->io_tree,
			    start_pos, last_pos - 1, GFP_NOFS);
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
		ordered = btrfs_lookup_first_ordered_extent(inode, last_pos -1);
		if (ordered &&
		    ordered->file_offset + ordered->len > start_pos &&
		    ordered->file_offset < last_pos) {
			btrfs_put_ordered_extent(ordered);
			unlock_extent(&BTRFS_I(inode)->io_tree,
				      start_pos, last_pos - 1, GFP_NOFS);
			for (i = 0; i < num_pages; i++) {
				unlock_page(pages[i]);
				page_cache_release(pages[i]);
			}
			btrfs_wait_ordered_range(inode, start_pos,
						 last_pos - start_pos);
			goto again;
		}
		if (ordered)
			btrfs_put_ordered_extent(ordered);

823 824 825
		clear_extent_bits(&BTRFS_I(inode)->io_tree, start_pos,
				  last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC,
				  GFP_NOFS);
826 827
		unlock_extent(&BTRFS_I(inode)->io_tree,
			      start_pos, last_pos - 1, GFP_NOFS);
828
	}
829 830 831 832 833 834 835 836 837
	for (i = 0; i < num_pages; i++) {
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
		ClearPageDirty(pages[i]);
#else
		cancel_dirty_page(pages[i], PAGE_CACHE_SIZE);
#endif
		set_page_extent_mapped(pages[i]);
		WARN_ON(!PageLocked(pages[i]));
	}
C
Chris Mason 已提交
838 839 840 841 842 843 844
	return 0;
}

static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
	loff_t pos;
845 846 847
	loff_t start_pos;
	ssize_t num_written = 0;
	ssize_t err = 0;
C
Chris Mason 已提交
848
	int ret = 0;
849
	struct inode *inode = fdentry(file)->d_inode;
C
Chris Mason 已提交
850
	struct btrfs_root *root = BTRFS_I(inode)->root;
851 852
	struct page **pages = NULL;
	int nrptrs;
C
Chris Mason 已提交
853 854 855
	struct page *pinned[2];
	unsigned long first_index;
	unsigned long last_index;
856 857 858

	nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
		     PAGE_CACHE_SIZE / (sizeof(struct page *)));
C
Chris Mason 已提交
859 860
	pinned[0] = NULL;
	pinned[1] = NULL;
861

C
Chris Mason 已提交
862
	pos = *ppos;
863 864
	start_pos = pos;

C
Chris Mason 已提交
865 866 867 868
	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
	current->backing_dev_info = inode->i_mapping->backing_dev_info;
	err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
	if (err)
869
		goto out_nolock;
C
Chris Mason 已提交
870
	if (count == 0)
871
		goto out_nolock;
872 873 874
#ifdef REMOVE_SUID_PATH
	err = remove_suid(&file->f_path);
#else
875
	err = remove_suid(fdentry(file));
876
#endif
C
Chris Mason 已提交
877
	if (err)
878
		goto out_nolock;
C
Chris Mason 已提交
879 880
	file_update_time(file);

881
	pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
C
Chris Mason 已提交
882 883 884 885 886

	mutex_lock(&inode->i_mutex);
	first_index = pos >> PAGE_CACHE_SHIFT;
	last_index = (pos + count) >> PAGE_CACHE_SHIFT;

887 888 889 890 891 892 893 894
	/*
	 * if this is a nodatasum mount, force summing off for the inode
	 * all the time.  That way a later mount with summing on won't
	 * get confused
	 */
	if (btrfs_test_opt(root, NODATASUM))
		btrfs_set_flag(inode, NODATASUM);

C
Chris Mason 已提交
895 896 897 898 899 900 901 902
	/*
	 * there are lots of better ways to do this, but this code
	 * makes sure the first and last page in the file range are
	 * up to date and ready for cow
	 */
	if ((pos & (PAGE_CACHE_SIZE - 1))) {
		pinned[0] = grab_cache_page(inode->i_mapping, first_index);
		if (!PageUptodate(pinned[0])) {
C
Chris Mason 已提交
903
			ret = btrfs_readpage(NULL, pinned[0]);
C
Chris Mason 已提交
904 905 906 907 908 909 910 911 912
			BUG_ON(ret);
			wait_on_page_locked(pinned[0]);
		} else {
			unlock_page(pinned[0]);
		}
	}
	if ((pos + count) & (PAGE_CACHE_SIZE - 1)) {
		pinned[1] = grab_cache_page(inode->i_mapping, last_index);
		if (!PageUptodate(pinned[1])) {
C
Chris Mason 已提交
913
			ret = btrfs_readpage(NULL, pinned[1]);
C
Chris Mason 已提交
914 915 916 917 918 919 920 921 922
			BUG_ON(ret);
			wait_on_page_locked(pinned[1]);
		} else {
			unlock_page(pinned[1]);
		}
	}

	while(count > 0) {
		size_t offset = pos & (PAGE_CACHE_SIZE - 1);
923 924
		size_t write_bytes = min(count, nrptrs *
					(size_t)PAGE_CACHE_SIZE -
925
					 offset);
C
Chris Mason 已提交
926 927 928
		size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
					PAGE_CACHE_SHIFT;

929
		WARN_ON(num_pages > nrptrs);
C
Chris Mason 已提交
930
		memset(pages, 0, sizeof(pages));
931 932 933 934 935

		ret = btrfs_check_free_space(root, write_bytes, 0);
		if (ret)
			goto out;

C
Chris Mason 已提交
936 937
		ret = prepare_pages(root, file, pages, num_pages,
				    pos, first_index, last_index,
938
				    write_bytes);
939 940
		if (ret)
			goto out;
C
Chris Mason 已提交
941 942 943

		ret = btrfs_copy_from_user(pos, num_pages,
					   write_bytes, pages, buf);
944 945 946 947
		if (ret) {
			btrfs_drop_pages(pages, num_pages);
			goto out;
		}
C
Chris Mason 已提交
948 949 950 951

		ret = dirty_and_release_pages(NULL, root, file, pages,
					      num_pages, pos, write_bytes);
		btrfs_drop_pages(pages, num_pages);
952 953
		if (ret)
			goto out;
C
Chris Mason 已提交
954 955 956 957 958 959

		buf += write_bytes;
		count -= write_bytes;
		pos += write_bytes;
		num_written += write_bytes;

960
		balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
961 962
		if (num_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
			btrfs_btree_balance_dirty(root, 1);
C
Chris Mason 已提交
963 964 965
		cond_resched();
	}
out:
966
	mutex_unlock(&inode->i_mutex);
967

968
out_nolock:
969
	kfree(pages);
C
Chris Mason 已提交
970 971 972 973 974
	if (pinned[0])
		page_cache_release(pinned[0]);
	if (pinned[1])
		page_cache_release(pinned[1]);
	*ppos = pos;
975 976 977 978 979 980

	if (num_written > 0 && ((file->f_flags & O_SYNC) || IS_SYNC(inode))) {
		err = sync_page_range(inode, inode->i_mapping,
				      start_pos, num_written);
		if (err < 0)
			num_written = err;
981
	} else if (num_written > 0 && (file->f_flags & O_DIRECT)) {
982
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
983 984 985 986 987
		do_sync_file_range(file, start_pos,
				      start_pos + num_written - 1,
				      SYNC_FILE_RANGE_WRITE |
				      SYNC_FILE_RANGE_WAIT_AFTER);
#else
988 989 990 991
		do_sync_mapping_range(inode->i_mapping, start_pos,
				      start_pos + num_written - 1,
				      SYNC_FILE_RANGE_WRITE |
				      SYNC_FILE_RANGE_WAIT_AFTER);
992
#endif
993 994 995
		invalidate_mapping_pages(inode->i_mapping,
		      start_pos >> PAGE_CACHE_SHIFT,
		     (start_pos + num_written - 1) >> PAGE_CACHE_SHIFT);
996
	}
C
Chris Mason 已提交
997 998 999 1000
	current->backing_dev_info = NULL;
	return num_written ? num_written : err;
}

S
Sage Weil 已提交
1001
int btrfs_release_file(struct inode * inode, struct file * filp)
1002
{
S
Sage Weil 已提交
1003 1004
	if (filp->private_data)
		btrfs_ioctl_trans_end(filp);
1005 1006 1007
	return 0;
}

C
Chris Mason 已提交
1008 1009 1010 1011 1012
static int btrfs_sync_file(struct file *file,
			   struct dentry *dentry, int datasync)
{
	struct inode *inode = dentry->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
1013
	int ret = 0;
C
Chris Mason 已提交
1014 1015 1016
	struct btrfs_trans_handle *trans;

	/*
1017 1018
	 * check the transaction that last modified this inode
	 * and see if its already been committed
C
Chris Mason 已提交
1019
	 */
1020 1021
	if (!BTRFS_I(inode)->last_trans)
		goto out;
1022

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
	mutex_lock(&root->fs_info->trans_mutex);
	if (BTRFS_I(inode)->last_trans <=
	    root->fs_info->last_trans_committed) {
		BTRFS_I(inode)->last_trans = 0;
		mutex_unlock(&root->fs_info->trans_mutex);
		goto out;
	}
	mutex_unlock(&root->fs_info->trans_mutex);

	/*
1033 1034
	 * ok we haven't committed the transaction yet, lets do a commit
	 */
S
Sage Weil 已提交
1035 1036 1037
	if (file->private_data)
		btrfs_ioctl_trans_end(file);

C
Chris Mason 已提交
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	trans = btrfs_start_transaction(root, 1);
	if (!trans) {
		ret = -ENOMEM;
		goto out;
	}
	ret = btrfs_commit_transaction(trans, root);
out:
	return ret > 0 ? EIO : ret;
}

C
Chris Mason 已提交
1048
static struct vm_operations_struct btrfs_file_vm_ops = {
1049 1050 1051 1052 1053 1054
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
	.nopage         = filemap_nopage,
	.populate       = filemap_populate,
#else
	.fault		= filemap_fault,
#endif
C
Chris Mason 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	.page_mkwrite	= btrfs_page_mkwrite,
};

static int btrfs_file_mmap(struct file	*filp, struct vm_area_struct *vma)
{
	vma->vm_ops = &btrfs_file_vm_ops;
	file_accessed(filp);
	return 0;
}

C
Chris Mason 已提交
1065 1066 1067
struct file_operations btrfs_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
C
Chris Mason 已提交
1068
	.aio_read       = generic_file_aio_read,
C
Chris Mason 已提交
1069
	.splice_read	= generic_file_splice_read,
1070 1071 1072
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	.sendfile	= generic_file_sendfile,
#endif
C
Chris Mason 已提交
1073
	.write		= btrfs_file_write,
C
Chris Mason 已提交
1074
	.mmap		= btrfs_file_mmap,
C
Chris Mason 已提交
1075
	.open		= generic_file_open,
1076
	.release	= btrfs_release_file,
C
Chris Mason 已提交
1077
	.fsync		= btrfs_sync_file,
C
Christoph Hellwig 已提交
1078
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
1079
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
1080
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
1081 1082 1083
#endif
};