file.c 23.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 39 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
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"


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

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

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

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

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

123 124
		path->slots[0]--;
		leaf = path->nodes[0];
125 126 127 128 129 130 131
		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;
132 133 134 135 136 137 138 139 140 141 142 143
		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;
144
		u64 found_end;
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159

		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]));
160
		found_end = key.offset + found_size;
161

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

168
			ret = btrfs_extend_item(trans, root, path,
169
						offset + size - found_end);
170 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);
		}
178 179 180 181
		if (found_end < offset) {
			ptr = btrfs_file_extent_inline_start(ei) + found_size;
			memset_extent_buffer(leaf, 0, ptr, offset - found_end);
		}
182 183 184
	} else {
insert:
		btrfs_release_path(root, path);
185 186
		datasize = offset + size - key.offset;
		datasize = btrfs_file_extent_calc_inline_size(datasize);
187 188 189 190 191 192 193 194 195 196 197 198 199
		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);
	}
200
	ptr = btrfs_file_extent_inline_start(ei) + offset - key.offset;
201 202 203 204 205 206

	cur_size = size;
	i = 0;
	while (size > 0) {
		page = pages[i];
		kaddr = kmap_atomic(page, KM_USER0);
J
Jens Axboe 已提交
207
		cur_size = min_t(size_t, PAGE_CACHE_SIZE - page_offset, size);
208 209 210 211 212 213 214 215 216 217
		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++;
	}
218
	btrfs_mark_buffer_dirty(leaf);
219 220 221 222 223
fail:
	btrfs_free_path(path);
	return err;
}

C
Chris Mason 已提交
224 225 226 227 228 229 230 231 232
static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct file *file,
				   struct page **pages,
				   size_t num_pages,
				   loff_t pos,
				   size_t write_bytes)
{
	int err = 0;
233
	int i;
234
	struct inode *inode = fdentry(file)->d_inode;
235 236
	struct extent_map *em;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
237 238
	u64 hint_byte;
	u64 num_bytes;
239 240 241
	u64 start_pos;
	u64 end_of_last_block;
	u64 end_pos = pos + write_bytes;
242
	u64 inline_size;
243 244 245 246
	loff_t isize = i_size_read(inode);
	em = alloc_extent_map(GFP_NOFS);
	if (!em)
		return -ENOMEM;
C
Chris Mason 已提交
247

248
	em->bdev = inode->i_sb->s_bdev;
C
Chris Mason 已提交
249

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

254
	down_read(&BTRFS_I(inode)->root->snap_sem);
255 256
	end_of_last_block = start_pos + num_bytes - 1;

257
	lock_extent(em_tree, start_pos, end_of_last_block, GFP_NOFS);
258 259 260 261 262 263 264
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	if (!trans) {
		err = -ENOMEM;
		goto out_unlock;
	}
	btrfs_set_trans_block_group(trans, inode);
265 266
	inode->i_blocks += num_bytes >> 9;
	hint_byte = 0;
267 268

	if ((end_of_last_block & 4095) == 0) {
269
		printk("strange end of last %Lu %zu %Lu\n", start_pos, write_bytes, end_of_last_block);
270 271 272 273 274 275 276 277 278
	}
	set_extent_uptodate(em_tree, start_pos, end_of_last_block, GFP_NOFS);

	/* FIXME...EIEIO, ENOSPC and more */

	/* insert any holes we need to create */
	if (inode->i_size < start_pos) {
		u64 last_pos_in_file;
		u64 hole_size;
279
		u64 mask = root->sectorsize - 1;
280 281
		last_pos_in_file = (isize + mask) & ~mask;
		hole_size = (start_pos - last_pos_in_file + mask) & ~mask;
C
Chris Mason 已提交
282

283
		if (last_pos_in_file < start_pos) {
C
Chris Mason 已提交
284 285 286
			err = btrfs_drop_extents(trans, root, inode,
						 last_pos_in_file,
						 last_pos_in_file + hole_size,
287
						 last_pos_in_file,
288
						 &hint_byte);
C
Chris Mason 已提交
289 290 291
			if (err)
				goto failed;

292 293 294 295 296 297
			err = btrfs_insert_file_extent(trans, root,
						       inode->i_ino,
						       last_pos_in_file,
						       0, 0, hole_size);
		}
		if (err)
C
Chris Mason 已提交
298
			goto failed;
299 300 301 302 303 304
	}

	/*
	 * either allocate an extent for the new bytes or setup the key
	 * to show we are doing inline data in the extent
	 */
305 306
	inline_size = end_pos;
	if (isize >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
307
	    inline_size > 32768 ||
308
	    inline_size >= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
309
		u64 last_end;
310
		u64 existing_delalloc = 0;
311

312 313 314
		for (i = 0; i < num_pages; i++) {
			struct page *p = pages[i];
			SetPageUptodate(p);
315
			set_page_dirty(p);
C
Chris Mason 已提交
316
		}
317 318
		last_end = (u64)(pages[num_pages -1]->index) <<
				PAGE_CACHE_SHIFT;
319
		last_end += PAGE_CACHE_SIZE - 1;
320 321 322 323 324 325 326
		if (start_pos < isize) {
			u64 delalloc_start = start_pos;
			existing_delalloc = count_range_bits(em_tree,
					     &delalloc_start,
					     end_of_last_block, (u64)-1,
					     EXTENT_DELALLOC);
		}
327 328
		set_extent_delalloc(em_tree, start_pos, end_of_last_block,
				 GFP_NOFS);
329 330 331 332
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->delalloc_bytes += (end_of_last_block + 1 -
					  start_pos) - existing_delalloc;
		spin_unlock(&root->fs_info->delalloc_lock);
333
	} else {
334
		u64 aligned_end;
335
		/* step one, delete the existing extents in this range */
336 337
		aligned_end = (pos + write_bytes + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
C
Chris Mason 已提交
338
		err = btrfs_drop_extents(trans, root, inode, start_pos,
339
					 aligned_end, aligned_end, &hint_byte);
C
Chris Mason 已提交
340 341
		if (err)
			goto failed;
342 343 344
		if (isize > inline_size)
			inline_size = min_t(u64, isize, aligned_end);
		inline_size -= start_pos;
345
		err = insert_inline_extent(trans, root, inode, start_pos,
346
					   inline_size, pages, 0, num_pages);
347 348 349 350 351
		BUG_ON(err);
	}
	if (end_pos > isize) {
		i_size_write(inode, end_pos);
		btrfs_update_inode(trans, root, inode);
C
Chris Mason 已提交
352 353
	}
failed:
354 355 356
	err = btrfs_end_transaction(trans, root);
out_unlock:
	mutex_unlock(&root->fs_info->fs_mutex);
357
	unlock_extent(em_tree, start_pos, end_of_last_block, GFP_NOFS);
358
	free_extent_map(em);
359
	up_read(&BTRFS_I(inode)->root->snap_sem);
C
Chris Mason 已提交
360 361 362
	return err;
}

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end)
{
	struct extent_map *em;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;

	while(1) {
		em = lookup_extent_mapping(em_tree, start, end);
		if (!em)
			break;
		remove_extent_mapping(em_tree, em);
		/* once for us */
		free_extent_map(em);
		/* once for the tree*/
		free_extent_map(em);
	}
	return 0;
}

C
Chris Mason 已提交
381 382 383 384 385 386 387 388 389 390 391
/*
 * 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,
392
		       u64 start, u64 end, u64 inline_limit, u64 *hint_byte)
C
Chris Mason 已提交
393
{
394 395
	u64 extent_end = 0;
	u64 search_start = start;
396
	struct extent_buffer *leaf;
C
Chris Mason 已提交
397 398
	struct btrfs_file_extent_item *extent;
	struct btrfs_path *path;
399 400 401 402
	struct btrfs_key key;
	struct btrfs_file_extent_item old;
	int keep;
	int slot;
C
Chris Mason 已提交
403 404 405 406
	int bookend;
	int found_type;
	int found_extent;
	int found_inline;
C
Chris Mason 已提交
407
	int recow;
408
	int ret;
C
Chris Mason 已提交
409

410 411
	btrfs_drop_extent_cache(inode, start, end - 1);

C
Chris Mason 已提交
412 413 414 415
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	while(1) {
C
Chris Mason 已提交
416
		recow = 0;
C
Chris Mason 已提交
417 418 419 420 421 422 423 424 425 426 427 428
		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]--;
		}
429
next_slot:
C
Chris Mason 已提交
430 431 432 433 434
		keep = 0;
		bookend = 0;
		found_extent = 0;
		found_inline = 0;
		extent = NULL;
435
		leaf = path->nodes[0];
C
Chris Mason 已提交
436
		slot = path->slots[0];
437
		ret = 0;
438
		btrfs_item_key_to_cpu(leaf, &key, slot);
C
Chris Mason 已提交
439 440 441
		if (key.offset >= end || key.objectid != inode->i_ino) {
			goto out;
		}
442
		if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY) {
C
Chris Mason 已提交
443 444
			goto out;
		}
C
Chris Mason 已提交
445 446 447 448
		if (recow) {
			search_start = key.offset;
			continue;
		}
449 450 451
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
			extent = btrfs_item_ptr(leaf, slot,
						struct btrfs_file_extent_item);
452
			found_type = btrfs_file_extent_type(leaf, extent);
453
			if (found_type == BTRFS_FILE_EXTENT_REG) {
454 455 456 457 458 459
				extent_end =
				     btrfs_file_extent_disk_bytenr(leaf,
								   extent);
				if (extent_end)
					*hint_byte = extent_end;

460
				extent_end = key.offset +
461
				     btrfs_file_extent_num_bytes(leaf, extent);
462 463
				found_extent = 1;
			} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
464 465
				struct btrfs_item *item;
				item = btrfs_item_nr(leaf, slot);
466 467
				found_inline = 1;
				extent_end = key.offset +
468
				     btrfs_file_extent_inline_len(leaf, item);
469 470 471
			}
		} else {
			extent_end = search_start;
C
Chris Mason 已提交
472 473 474
		}

		/* we found nothing we can drop */
475 476 477 478
		if ((!found_extent && !found_inline) ||
		    search_start >= extent_end) {
			int nextret;
			u32 nritems;
479
			nritems = btrfs_header_nritems(leaf);
480 481 482 483
			if (slot >= nritems - 1) {
				nextret = btrfs_next_leaf(root, path);
				if (nextret)
					goto out;
C
Chris Mason 已提交
484
				recow = 1;
485 486 487 488
			} else {
				path->slots[0]++;
			}
			goto next_slot;
C
Chris Mason 已提交
489 490 491
		}

		if (found_inline) {
492
			u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
493 494 495
			search_start = (extent_end + mask) & ~mask;
		} else
			search_start = extent_end;
Y
Yan 已提交
496
		if (end <= extent_end && start >= key.offset && found_inline) {
497
			*hint_byte = EXTENT_MAP_INLINE;
Y
Yan 已提交
498
			continue;
499
		}
C
Chris Mason 已提交
500 501
		if (end < extent_end && end >= key.offset) {
			if (found_extent) {
502 503 504 505
				u64 disk_bytenr =
				    btrfs_file_extent_disk_bytenr(leaf, extent);
				u64 disk_num_bytes =
				    btrfs_file_extent_disk_num_bytes(leaf,
506 507 508 509
								      extent);
				read_extent_buffer(leaf, &old,
						   (unsigned long)extent,
						   sizeof(old));
510
				if (disk_bytenr != 0) {
C
Chris Mason 已提交
511
					ret = btrfs_inc_extent_ref(trans, root,
512 513 514 515
					         disk_bytenr, disk_num_bytes,
						 root->root_key.objectid,
						 trans->transid,
						 key.objectid, end);
C
Chris Mason 已提交
516 517 518
					BUG_ON(ret);
				}
			}
519 520
			bookend = 1;
			if (found_inline && start <= key.offset &&
521
			    inline_limit < extent_end)
522
				keep = 1;
C
Chris Mason 已提交
523 524 525 526 527 528
		}
		/* truncate existing extent */
		if (start > key.offset) {
			u64 new_num;
			u64 old_num;
			keep = 1;
529
			WARN_ON(start & (root->sectorsize - 1));
C
Chris Mason 已提交
530
			if (found_extent) {
531 532 533 534 535 536 537 538
				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 已提交
539
					inode->i_blocks -=
540
						(old_num - new_num) >> 9;
C
Chris Mason 已提交
541
				}
542 543
				btrfs_set_file_extent_num_bytes(leaf, extent,
								new_num);
544
				btrfs_mark_buffer_dirty(leaf);
545 546 547
			} else if (key.offset < inline_limit &&
				   (end > extent_end) &&
				   (inline_limit < extent_end)) {
548 549
				u32 new_size;
				new_size = btrfs_file_extent_calc_inline_size(
550
						   inline_limit - key.offset);
551
				btrfs_truncate_item(trans, root, path,
552
						    new_size, 1);
C
Chris Mason 已提交
553 554 555 556
			}
		}
		/* delete the entire extent */
		if (!keep) {
557 558 559
			u64 disk_bytenr = 0;
			u64 disk_num_bytes = 0;
			u64 extent_num_bytes = 0;
560
			u64 root_gen;
561
			u64 root_owner;
562

563 564
			root_gen = btrfs_header_generation(leaf);
			root_owner = btrfs_header_owner(leaf);
C
Chris Mason 已提交
565
			if (found_extent) {
566 567
				disk_bytenr =
				      btrfs_file_extent_disk_bytenr(leaf,
568
								     extent);
569 570
				disk_num_bytes =
				      btrfs_file_extent_disk_num_bytes(leaf,
571
								       extent);
572 573 574 575 576
				extent_num_bytes =
				      btrfs_file_extent_num_bytes(leaf, extent);
				*hint_byte =
					btrfs_file_extent_disk_bytenr(leaf,
								      extent);
C
Chris Mason 已提交
577 578
			}
			ret = btrfs_del_item(trans, root, path);
579
			/* TODO update progress marker and return */
C
Chris Mason 已提交
580 581 582
			BUG_ON(ret);
			btrfs_release_path(root, path);
			extent = NULL;
583 584
			if (found_extent && disk_bytenr != 0) {
				inode->i_blocks -= extent_num_bytes >> 9;
C
Chris Mason 已提交
585
				ret = btrfs_free_extent(trans, root,
586 587
						disk_bytenr,
						disk_num_bytes,
588
						root_owner,
589 590
						root_gen, inode->i_ino,
						key.offset, 0);
C
Chris Mason 已提交
591 592 593 594 595 596 597 598 599 600
			}

			BUG_ON(ret);
			if (!bookend && search_start >= end) {
				ret = 0;
				goto out;
			}
			if (!bookend)
				continue;
		}
601
		if (bookend && found_inline && start <= key.offset &&
602
		    inline_limit < extent_end && key.offset <= inline_limit) {
603 604
			u32 new_size;
			new_size = btrfs_file_extent_calc_inline_size(
605
						   extent_end - inline_limit);
606 607
			btrfs_truncate_item(trans, root, path, new_size, 0);
		}
C
Chris Mason 已提交
608 609 610 611 612 613 614 615 616
		/* 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));
617

618
			leaf = path->nodes[0];
619
			if (ret) {
620 621
				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);
622
			}
C
Chris Mason 已提交
623
			BUG_ON(ret);
624 625 626 627 628 629
			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,
630 631 632 633 634
				    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);
635
			btrfs_set_file_extent_type(leaf, extent,
C
Chris Mason 已提交
636
						   BTRFS_FILE_EXTENT_REG);
637

C
Chris Mason 已提交
638
			btrfs_mark_buffer_dirty(path->nodes[0]);
639
			if (le64_to_cpu(old.disk_bytenr) != 0) {
C
Chris Mason 已提交
640
				inode->i_blocks +=
641 642
				      btrfs_file_extent_num_bytes(leaf,
								  extent) >> 9;
C
Chris Mason 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
			}
			ret = 0;
			goto out;
		}
	}
out:
	btrfs_free_path(path);
	return ret;
}

/*
 * this gets pages into the page cache and locks them down
 */
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,
663
			 size_t write_bytes)
C
Chris Mason 已提交
664 665 666
{
	int i;
	unsigned long index = pos >> PAGE_CACHE_SHIFT;
667
	struct inode *inode = fdentry(file)->d_inode;
C
Chris Mason 已提交
668
	int err = 0;
669 670
	u64 start_pos;

671
	start_pos = pos & ~((u64)root->sectorsize - 1);
C
Chris Mason 已提交
672 673 674 675 676 677 678

	memset(pages, 0, num_pages * sizeof(struct page *));

	for (i = 0; i < num_pages; i++) {
		pages[i] = grab_cache_page(inode->i_mapping, index + i);
		if (!pages[i]) {
			err = -ENOMEM;
679
			BUG_ON(1);
C
Chris Mason 已提交
680
		}
681 682 683
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
		ClearPageDirty(pages[i]);
#else
C
Chris Mason 已提交
684
		cancel_dirty_page(pages[i], PAGE_CACHE_SIZE);
685
#endif
C
Chris Mason 已提交
686
		wait_on_page_writeback(pages[i]);
687
		set_page_extent_mapped(pages[i]);
688
		WARN_ON(!PageLocked(pages[i]));
C
Chris Mason 已提交
689 690 691 692 693 694 695 696
	}
	return 0;
}

static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
	loff_t pos;
697 698 699
	loff_t start_pos;
	ssize_t num_written = 0;
	ssize_t err = 0;
C
Chris Mason 已提交
700
	int ret = 0;
701
	struct inode *inode = fdentry(file)->d_inode;
C
Chris Mason 已提交
702
	struct btrfs_root *root = BTRFS_I(inode)->root;
703 704
	struct page **pages = NULL;
	int nrptrs;
C
Chris Mason 已提交
705 706 707
	struct page *pinned[2];
	unsigned long first_index;
	unsigned long last_index;
708 709 710

	nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
		     PAGE_CACHE_SIZE / (sizeof(struct page *)));
C
Chris Mason 已提交
711 712 713 714
	pinned[0] = NULL;
	pinned[1] = NULL;
	if (file->f_flags & O_DIRECT)
		return -EINVAL;
715

C
Chris Mason 已提交
716
	pos = *ppos;
717 718
	start_pos = pos;

C
Chris Mason 已提交
719 720 721 722
	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)
723
		goto out_nolock;
C
Chris Mason 已提交
724
	if (count == 0)
725
		goto out_nolock;
726
	err = remove_suid(fdentry(file));
C
Chris Mason 已提交
727
	if (err)
728
		goto out_nolock;
C
Chris Mason 已提交
729 730
	file_update_time(file);

731
	pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
C
Chris Mason 已提交
732 733 734 735 736 737 738 739 740 741 742 743 744

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

	/*
	 * 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 已提交
745
			ret = btrfs_readpage(NULL, pinned[0]);
C
Chris Mason 已提交
746 747 748 749 750 751 752 753 754
			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 已提交
755
			ret = btrfs_readpage(NULL, pinned[1]);
C
Chris Mason 已提交
756 757 758 759 760 761 762 763 764
			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);
765 766
		size_t write_bytes = min(count, nrptrs *
					(size_t)PAGE_CACHE_SIZE -
767
					 offset);
C
Chris Mason 已提交
768 769 770
		size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
					PAGE_CACHE_SHIFT;

771
		WARN_ON(num_pages > nrptrs);
C
Chris Mason 已提交
772
		memset(pages, 0, sizeof(pages));
773 774 775 776 777 778 779

		mutex_lock(&root->fs_info->fs_mutex);
		ret = btrfs_check_free_space(root, write_bytes, 0);
		mutex_unlock(&root->fs_info->fs_mutex);
		if (ret)
			goto out;

C
Chris Mason 已提交
780 781
		ret = prepare_pages(root, file, pages, num_pages,
				    pos, first_index, last_index,
782
				    write_bytes);
783 784
		if (ret)
			goto out;
C
Chris Mason 已提交
785 786 787

		ret = btrfs_copy_from_user(pos, num_pages,
					   write_bytes, pages, buf);
788 789 790 791
		if (ret) {
			btrfs_drop_pages(pages, num_pages);
			goto out;
		}
C
Chris Mason 已提交
792 793 794 795

		ret = dirty_and_release_pages(NULL, root, file, pages,
					      num_pages, pos, write_bytes);
		btrfs_drop_pages(pages, num_pages);
796 797
		if (ret)
			goto out;
C
Chris Mason 已提交
798 799 800 801 802 803

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

804
		balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
805 806
		if (num_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
			btrfs_btree_balance_dirty(root, 1);
C
Chris Mason 已提交
807 808 809
		cond_resched();
	}
out:
810 811
	mutex_unlock(&inode->i_mutex);
out_nolock:
812
	kfree(pages);
C
Chris Mason 已提交
813 814 815 816 817
	if (pinned[0])
		page_cache_release(pinned[0]);
	if (pinned[1])
		page_cache_release(pinned[1]);
	*ppos = pos;
818 819 820 821 822 823 824

	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;
	}
C
Chris Mason 已提交
825 826 827 828 829 830 831 832 833
	current->backing_dev_info = NULL;
	return num_written ? num_written : err;
}

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;
834
	int ret = 0;
C
Chris Mason 已提交
835 836 837
	struct btrfs_trans_handle *trans;

	/*
838 839
	 * check the transaction that last modified this inode
	 * and see if its already been committed
C
Chris Mason 已提交
840 841
	 */
	mutex_lock(&root->fs_info->fs_mutex);
842 843 844 845 846 847 848 849 850 851 852 853
	if (!BTRFS_I(inode)->last_trans)
		goto out;
	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);

	/*
854 855
	 * ok we haven't committed the transaction yet, lets do a commit
	 */
C
Chris Mason 已提交
856 857 858 859 860 861 862
	trans = btrfs_start_transaction(root, 1);
	if (!trans) {
		ret = -ENOMEM;
		goto out;
	}
	ret = btrfs_commit_transaction(trans, root);
out:
863
	mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
864 865 866
	return ret > 0 ? EIO : ret;
}

C
Chris Mason 已提交
867
static struct vm_operations_struct btrfs_file_vm_ops = {
868 869 870 871 872 873
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
	.nopage         = filemap_nopage,
	.populate       = filemap_populate,
#else
	.fault		= filemap_fault,
#endif
C
Chris Mason 已提交
874 875 876 877 878 879 880 881 882 883
	.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 已提交
884 885 886
struct file_operations btrfs_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= do_sync_read,
C
Chris Mason 已提交
887
	.aio_read       = generic_file_aio_read,
C
Chris Mason 已提交
888
	.splice_read	= generic_file_splice_read,
889 890 891
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	.sendfile	= generic_file_sendfile,
#endif
C
Chris Mason 已提交
892
	.write		= btrfs_file_write,
C
Chris Mason 已提交
893
	.mmap		= btrfs_file_mmap,
C
Chris Mason 已提交
894 895
	.open		= generic_file_open,
	.fsync		= btrfs_sync_file,
C
Christoph Hellwig 已提交
896
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
897
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
898
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
899 900 901
#endif
};