file.c 29.1 KB
Newer Older
Chris Mason's avatar
Chris Mason committed
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.
 */

Chris Mason's avatar
Chris Mason committed
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>
Chris Mason's avatar
Chris Mason committed
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"
Chris Mason's avatar
Chris Mason committed
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


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;
Chris Mason's avatar
Chris Mason committed
78
		ClearPageChecked(pages[i]);
Chris Mason's avatar
Chris Mason committed
79
80
81
82
83
84
		unlock_page(pages[i]);
		mark_page_accessed(pages[i]);
		page_cache_release(pages[i]);
	}
}

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

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

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

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

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

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

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

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

	cur_size = size;
	i = 0;
	while (size > 0) {
		page = pages[i];
		kaddr = kmap_atomic(page, KM_USER0);
Jens Axboe's avatar
Jens Axboe committed
211
		cur_size = min_t(size_t, PAGE_CACHE_SIZE - page_offset, size);
212
213
214
215
216
217
218
219
220
221
		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++;
	}
222
	btrfs_mark_buffer_dirty(leaf);
223
224
225
226
227
fail:
	btrfs_free_path(path);
	return err;
}

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

249
	start_pos = pos & ~((u64)root->sectorsize - 1);
250
251
	num_bytes = (write_bytes + pos - start_pos +
		    root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
Chris Mason's avatar
Chris Mason committed
252

253
254
	end_of_last_block = start_pos + num_bytes - 1;

255
	lock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
Chris Mason's avatar
Chris Mason committed
256
	trans = btrfs_join_transaction(root, 1);
257
258
259
260
261
	if (!trans) {
		err = -ENOMEM;
		goto out_unlock;
	}
	btrfs_set_trans_block_group(trans, inode);
262
	hint_byte = 0;
263
264

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

	/* FIXME...EIEIO, ENOSPC and more */
	/* insert any holes we need to create */
271
	if (isize < start_pos) {
272
273
		u64 last_pos_in_file;
		u64 hole_size;
274
		u64 mask = root->sectorsize - 1;
275
		last_pos_in_file = (isize + mask) & ~mask;
276
		hole_size = (start_pos - last_pos_in_file + mask) & ~mask;
277
278
279
		if (hole_size > 0) {
			btrfs_wait_ordered_range(inode, last_pos_in_file,
						 last_pos_in_file + hole_size);
280
			mutex_lock(&BTRFS_I(inode)->extent_mutex);
Chris Mason's avatar
Chris Mason committed
281
282
283
			err = btrfs_drop_extents(trans, root, inode,
						 last_pos_in_file,
						 last_pos_in_file + hole_size,
284
						 last_pos_in_file,
285
						 &hint_byte);
Chris Mason's avatar
Chris Mason committed
286
287
288
			if (err)
				goto failed;

289
290
291
			err = btrfs_insert_file_extent(trans, root,
						       inode->i_ino,
						       last_pos_in_file,
Sage Weil's avatar
Sage Weil committed
292
						       0, 0, hole_size, 0);
293
294
			btrfs_drop_extent_cache(inode, last_pos_in_file,
					last_pos_in_file + hole_size -1);
295
			mutex_unlock(&BTRFS_I(inode)->extent_mutex);
296
			btrfs_check_file(root, inode);
297
298
		}
		if (err)
Chris Mason's avatar
Chris Mason committed
299
			goto failed;
300
301
302
303
304
305
	}

	/*
	 * either allocate an extent for the new bytes or setup the key
	 * to show we are doing inline data in the extent
	 */
306
307
	inline_size = end_pos;
	if (isize >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
308
309
	    inline_size > root->fs_info->max_inline ||
	    (inline_size & (root->sectorsize -1)) == 0 ||
310
	    inline_size >= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
311
312
313
314
315
316
		/* 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);
317
318
319
		for (i = 0; i < num_pages; i++) {
			struct page *p = pages[i];
			SetPageUptodate(p);
320
			ClearPageChecked(p);
321
			set_page_dirty(p);
Chris Mason's avatar
Chris Mason committed
322
		}
323
	} else {
324
		u64 aligned_end;
325
		/* step one, delete the existing extents in this range */
326
327
		aligned_end = (pos + write_bytes + root->sectorsize - 1) &
			~((u64)root->sectorsize - 1);
328
		mutex_lock(&BTRFS_I(inode)->extent_mutex);
Chris Mason's avatar
Chris Mason committed
329
		err = btrfs_drop_extents(trans, root, inode, start_pos,
330
					 aligned_end, aligned_end, &hint_byte);
Chris Mason's avatar
Chris Mason committed
331
332
		if (err)
			goto failed;
333
334
335
		if (isize > inline_size)
			inline_size = min_t(u64, isize, aligned_end);
		inline_size -= start_pos;
336
		err = insert_inline_extent(trans, root, inode, start_pos,
337
					   inline_size, pages, 0, num_pages);
338
		btrfs_drop_extent_cache(inode, start_pos, aligned_end - 1);
339
		BUG_ON(err);
340
341
		mutex_unlock(&BTRFS_I(inode)->extent_mutex);
		did_inline = 1;
342
343
344
	}
	if (end_pos > isize) {
		i_size_write(inode, end_pos);
345
346
		if (did_inline)
			BTRFS_I(inode)->disk_i_size = end_pos;
347
		btrfs_update_inode(trans, root, inode);
Chris Mason's avatar
Chris Mason committed
348
349
	}
failed:
350
	err = btrfs_end_transaction(trans, root);
351
out_unlock:
352
	unlock_extent(io_tree, start_pos, end_of_last_block, GFP_NOFS);
Chris Mason's avatar
Chris Mason committed
353
354
355
	return err;
}

356
357
358
int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end)
{
	struct extent_map *em;
359
360
	struct extent_map *split = NULL;
	struct extent_map *split2 = NULL;
361
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
362
	u64 len = end - start + 1;
363
364
	int ret;
	int testend = 1;
365

366
	WARN_ON(end < start);
367
	if (end == (u64)-1) {
368
		len = (u64)-1;
369
370
		testend = 0;
	}
371
	while(1) {
372
373
374
375
376
		if (!split)
			split = alloc_extent_map(GFP_NOFS);
		if (!split2)
			split2 = alloc_extent_map(GFP_NOFS);

377
		spin_lock(&em_tree->lock);
378
		em = lookup_extent_mapping(em_tree, start, len);
379
380
		if (!em) {
			spin_unlock(&em_tree->lock);
381
			break;
382
		}
383
		if (test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
384
385
386
387
388
389
390
			printk(KERN_CRIT "inode %lu trying to drop pinned "
			       "extent start %llu end %llu, em [%llu %llu]\n",
			       inode->i_ino,
			       (unsigned long long)start,
			       (unsigned long long)end,
			       (unsigned long long)em->start,
			       (unsigned long long)em->len);
391
		}
392
		remove_extent_mapping(em_tree, em);
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422

		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;
		}
423
424
		spin_unlock(&em_tree->lock);

425
426
427
428
429
		/* once for us */
		free_extent_map(em);
		/* once for the tree*/
		free_extent_map(em);
	}
430
431
432
433
	if (split)
		free_extent_map(split);
	if (split2)
		free_extent_map(split2);
434
435
436
	return 0;
}

437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
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;

Chris Mason's avatar
Chris Mason committed
472
		if (found_key.offset < last_offset) {
473
474
475
476
477
478
479
480
481
482
483
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 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]++;
	}
Chris Mason's avatar
Chris Mason committed
497
	if (0 && last_offset < inode->i_size) {
498
499
500
501
502
503
504
505
506
507
508
509
510
		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
}

Chris Mason's avatar
Chris Mason committed
511
512
513
514
515
516
517
518
519
520
521
/*
 * 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,
522
		       u64 start, u64 end, u64 inline_limit, u64 *hint_byte)
Chris Mason's avatar
Chris Mason committed
523
{
524
525
	u64 extent_end = 0;
	u64 search_start = start;
526
	struct extent_buffer *leaf;
Chris Mason's avatar
Chris Mason committed
527
528
	struct btrfs_file_extent_item *extent;
	struct btrfs_path *path;
529
530
531
532
	struct btrfs_key key;
	struct btrfs_file_extent_item old;
	int keep;
	int slot;
Chris Mason's avatar
Chris Mason committed
533
534
535
536
	int bookend;
	int found_type;
	int found_extent;
	int found_inline;
Chris Mason's avatar
Chris Mason committed
537
	int recow;
538
	int ret;
Chris Mason's avatar
Chris Mason committed
539

540
541
	btrfs_drop_extent_cache(inode, start, end - 1);

Chris Mason's avatar
Chris Mason committed
542
543
544
545
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	while(1) {
Chris Mason's avatar
Chris Mason committed
546
		recow = 0;
Chris Mason's avatar
Chris Mason committed
547
548
549
550
551
552
553
554
555
556
557
558
		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]--;
		}
559
next_slot:
Chris Mason's avatar
Chris Mason committed
560
561
562
563
564
		keep = 0;
		bookend = 0;
		found_extent = 0;
		found_inline = 0;
		extent = NULL;
565
		leaf = path->nodes[0];
Chris Mason's avatar
Chris Mason committed
566
		slot = path->slots[0];
567
		ret = 0;
568
		btrfs_item_key_to_cpu(leaf, &key, slot);
569
570
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY &&
		    key.offset >= end) {
Chris Mason's avatar
Chris Mason committed
571
572
			goto out;
		}
573
574
		if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
		    key.objectid != inode->i_ino) {
Chris Mason's avatar
Chris Mason committed
575
576
			goto out;
		}
Chris Mason's avatar
Chris Mason committed
577
578
579
580
		if (recow) {
			search_start = key.offset;
			continue;
		}
581
582
583
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
			extent = btrfs_item_ptr(leaf, slot,
						struct btrfs_file_extent_item);
584
			found_type = btrfs_file_extent_type(leaf, extent);
585
			if (found_type == BTRFS_FILE_EXTENT_REG) {
586
587
588
589
590
591
				extent_end =
				     btrfs_file_extent_disk_bytenr(leaf,
								   extent);
				if (extent_end)
					*hint_byte = extent_end;

592
				extent_end = key.offset +
593
				     btrfs_file_extent_num_bytes(leaf, extent);
594
595
				found_extent = 1;
			} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
596
597
				struct btrfs_item *item;
				item = btrfs_item_nr(leaf, slot);
598
599
				found_inline = 1;
				extent_end = key.offset +
600
				     btrfs_file_extent_inline_len(leaf, item);
601
602
603
			}
		} else {
			extent_end = search_start;
Chris Mason's avatar
Chris Mason committed
604
605
606
		}

		/* we found nothing we can drop */
607
608
609
610
		if ((!found_extent && !found_inline) ||
		    search_start >= extent_end) {
			int nextret;
			u32 nritems;
611
			nritems = btrfs_header_nritems(leaf);
612
613
614
615
			if (slot >= nritems - 1) {
				nextret = btrfs_next_leaf(root, path);
				if (nextret)
					goto out;
Chris Mason's avatar
Chris Mason committed
616
				recow = 1;
617
618
619
620
			} else {
				path->slots[0]++;
			}
			goto next_slot;
Chris Mason's avatar
Chris Mason committed
621
622
623
		}

		if (found_inline) {
624
			u64 mask = root->sectorsize - 1;
Chris Mason's avatar
Chris Mason committed
625
626
627
			search_start = (extent_end + mask) & ~mask;
		} else
			search_start = extent_end;
Yan's avatar
Yan committed
628
		if (end <= extent_end && start >= key.offset && found_inline) {
629
			*hint_byte = EXTENT_MAP_INLINE;
Yan's avatar
Yan committed
630
			continue;
631
		}
Chris Mason's avatar
Chris Mason committed
632
633
		if (end < extent_end && end >= key.offset) {
			if (found_extent) {
634
635
636
637
				u64 disk_bytenr =
				    btrfs_file_extent_disk_bytenr(leaf, extent);
				u64 disk_num_bytes =
				    btrfs_file_extent_disk_num_bytes(leaf,
638
639
640
641
								      extent);
				read_extent_buffer(leaf, &old,
						   (unsigned long)extent,
						   sizeof(old));
642
				if (disk_bytenr != 0) {
Chris Mason's avatar
Chris Mason committed
643
					ret = btrfs_inc_extent_ref(trans, root,
644
645
646
647
					         disk_bytenr, disk_num_bytes,
						 root->root_key.objectid,
						 trans->transid,
						 key.objectid, end);
Chris Mason's avatar
Chris Mason committed
648
649
650
					BUG_ON(ret);
				}
			}
651
			bookend = 1;
652
			if (found_inline && start <= key.offset)
653
				keep = 1;
Chris Mason's avatar
Chris Mason committed
654
655
656
657
658
659
		}
		/* truncate existing extent */
		if (start > key.offset) {
			u64 new_num;
			u64 old_num;
			keep = 1;
660
			WARN_ON(start & (root->sectorsize - 1));
Chris Mason's avatar
Chris Mason committed
661
			if (found_extent) {
662
663
664
665
666
667
668
669
				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)) {
Chris Mason's avatar
Chris Mason committed
670
					dec_i_blocks(inode, old_num - new_num);
Chris Mason's avatar
Chris Mason committed
671
				}
672
673
				btrfs_set_file_extent_num_bytes(leaf, extent,
								new_num);
674
				btrfs_mark_buffer_dirty(leaf);
675
676
677
			} else if (key.offset < inline_limit &&
				   (end > extent_end) &&
				   (inline_limit < extent_end)) {
678
679
				u32 new_size;
				new_size = btrfs_file_extent_calc_inline_size(
680
						   inline_limit - key.offset);
Chris Mason's avatar
Chris Mason committed
681
682
				dec_i_blocks(inode, (extent_end - key.offset) -
					(inline_limit - key.offset));
683
				btrfs_truncate_item(trans, root, path,
684
						    new_size, 1);
Chris Mason's avatar
Chris Mason committed
685
686
687
688
			}
		}
		/* delete the entire extent */
		if (!keep) {
689
690
691
			u64 disk_bytenr = 0;
			u64 disk_num_bytes = 0;
			u64 extent_num_bytes = 0;
692
			u64 root_gen;
693
			u64 root_owner;
694

695
696
			root_gen = btrfs_header_generation(leaf);
			root_owner = btrfs_header_owner(leaf);
Chris Mason's avatar
Chris Mason committed
697
			if (found_extent) {
698
699
				disk_bytenr =
				      btrfs_file_extent_disk_bytenr(leaf,
700
								     extent);
701
702
				disk_num_bytes =
				      btrfs_file_extent_disk_num_bytes(leaf,
703
								       extent);
704
705
706
707
708
				extent_num_bytes =
				      btrfs_file_extent_num_bytes(leaf, extent);
				*hint_byte =
					btrfs_file_extent_disk_bytenr(leaf,
								      extent);
Chris Mason's avatar
Chris Mason committed
709
710
			}
			ret = btrfs_del_item(trans, root, path);
711
			/* TODO update progress marker and return */
Chris Mason's avatar
Chris Mason committed
712
713
714
			BUG_ON(ret);
			btrfs_release_path(root, path);
			extent = NULL;
715
			if (found_extent && disk_bytenr != 0) {
Chris Mason's avatar
Chris Mason committed
716
				dec_i_blocks(inode, extent_num_bytes);
Chris Mason's avatar
Chris Mason committed
717
				ret = btrfs_free_extent(trans, root,
718
719
						disk_bytenr,
						disk_num_bytes,
720
						root_owner,
721
722
						root_gen, inode->i_ino,
						key.offset, 0);
Chris Mason's avatar
Chris Mason committed
723
724
725
726
727
728
729
730
731
732
			}

			BUG_ON(ret);
			if (!bookend && search_start >= end) {
				ret = 0;
				goto out;
			}
			if (!bookend)
				continue;
		}
733
		if (bookend && found_inline && start <= key.offset) {
734
735
			u32 new_size;
			new_size = btrfs_file_extent_calc_inline_size(
736
						   extent_end - end);
Chris Mason's avatar
Chris Mason committed
737
738
			dec_i_blocks(inode, (extent_end - key.offset) -
					(extent_end - end));
739
740
			btrfs_truncate_item(trans, root, path, new_size, 0);
		}
Chris Mason's avatar
Chris Mason committed
741
742
743
744
745
746
747
748
749
		/* 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));
750

751
			leaf = path->nodes[0];
752
			if (ret) {
753
754
				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);
755
			}
Chris Mason's avatar
Chris Mason committed
756
			BUG_ON(ret);
757
758
759
760
761
762
			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,
763
764
765
766
767
				    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);
768
			btrfs_set_file_extent_type(leaf, extent,
Chris Mason's avatar
Chris Mason committed
769
						   BTRFS_FILE_EXTENT_REG);
770

Chris Mason's avatar
Chris Mason committed
771
			btrfs_mark_buffer_dirty(path->nodes[0]);
772
			if (le64_to_cpu(old.disk_bytenr) != 0) {
Chris Mason's avatar
Chris Mason committed
773
				inode->i_blocks +=
774
775
				      btrfs_file_extent_num_bytes(leaf,
								  extent) >> 9;
Chris Mason's avatar
Chris Mason committed
776
777
778
779
780
781
782
			}
			ret = 0;
			goto out;
		}
	}
out:
	btrfs_free_path(path);
Chris Mason's avatar
Chris Mason committed
783
	btrfs_check_file(root, inode);
Chris Mason's avatar
Chris Mason committed
784
785
786
787
788
789
	return ret;
}

/*
 * this gets pages into the page cache and locks them down
 */
790
791
792
793
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)
Chris Mason's avatar
Chris Mason committed
794
795
796
{
	int i;
	unsigned long index = pos >> PAGE_CACHE_SHIFT;
797
	struct inode *inode = fdentry(file)->d_inode;
Chris Mason's avatar
Chris Mason committed
798
	int err = 0;
799
	u64 start_pos;
800
	u64 last_pos;
801

802
	start_pos = pos & ~((u64)root->sectorsize - 1);
803
	last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT;
Chris Mason's avatar
Chris Mason committed
804
805

	memset(pages, 0, num_pages * sizeof(struct page *));
806
again:
Chris Mason's avatar
Chris Mason committed
807
808
809
810
	for (i = 0; i < num_pages; i++) {
		pages[i] = grab_cache_page(inode->i_mapping, index + i);
		if (!pages[i]) {
			err = -ENOMEM;
811
			BUG_ON(1);
Chris Mason's avatar
Chris Mason committed
812
		}
Chris Mason's avatar
Chris Mason committed
813
		wait_on_page_writeback(pages[i]);
Chris Mason's avatar
Chris Mason committed
814
	}
815
	if (start_pos < inode->i_size) {
816
		struct btrfs_ordered_extent *ordered;
817
818
		lock_extent(&BTRFS_I(inode)->io_tree,
			    start_pos, last_pos - 1, GFP_NOFS);
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
		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);

837
838
839
		clear_extent_bits(&BTRFS_I(inode)->io_tree, start_pos,
				  last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC,
				  GFP_NOFS);
840
841
		unlock_extent(&BTRFS_I(inode)->io_tree,
			      start_pos, last_pos - 1, GFP_NOFS);
842
	}
843
844
845
846
847
848
849
850
851
	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]));
	}
Chris Mason's avatar
Chris Mason committed
852
853
854
855
856
857
858
	return 0;
}

static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
				size_t count, loff_t *ppos)
{
	loff_t pos;
859
860
861
	loff_t start_pos;
	ssize_t num_written = 0;
	ssize_t err = 0;
Chris Mason's avatar
Chris Mason committed
862
	int ret = 0;
863
	struct inode *inode = fdentry(file)->d_inode;
Chris Mason's avatar
Chris Mason committed
864
	struct btrfs_root *root = BTRFS_I(inode)->root;
865
866
	struct page **pages = NULL;
	int nrptrs;
Chris Mason's avatar
Chris Mason committed
867
868
869
	struct page *pinned[2];
	unsigned long first_index;
	unsigned long last_index;
870
871
872

	nrptrs = min((count + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE,
		     PAGE_CACHE_SIZE / (sizeof(struct page *)));
Chris Mason's avatar
Chris Mason committed
873
874
	pinned[0] = NULL;
	pinned[1] = NULL;
875

Chris Mason's avatar
Chris Mason committed
876
	pos = *ppos;
877
878
	start_pos = pos;

Chris Mason's avatar
Chris Mason committed
879
880
881
882
	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)
883
		goto out_nolock;
Chris Mason's avatar
Chris Mason committed
884
	if (count == 0)
885
		goto out_nolock;
886
887
888
#ifdef REMOVE_SUID_PATH
	err = remove_suid(&file->f_path);
#else
889
890
891
# if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
	err = file_remove_suid(file);
# else
892
	err = remove_suid(fdentry(file));
893
# endif
894
#endif
Chris Mason's avatar
Chris Mason committed
895
	if (err)
896
		goto out_nolock;
Chris Mason's avatar
Chris Mason committed
897
898
	file_update_time(file);

899
	pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
Chris Mason's avatar
Chris Mason committed
900
901
902
903
904

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

905
906
907
908
909
910
911
912
	/*
	 * 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);

Chris Mason's avatar
Chris Mason committed
913
914
915
916
917
918
919
920
	/*
	 * 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])) {
Chris Mason's avatar
Chris Mason committed
921
			ret = btrfs_readpage(NULL, pinned[0]);
Chris Mason's avatar
Chris Mason committed
922
923
924
925
926
927
928
929
930
			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])) {
Chris Mason's avatar
Chris Mason committed
931
			ret = btrfs_readpage(NULL, pinned[1]);
Chris Mason's avatar
Chris Mason committed
932
933
934
935
936
937
938
939
940
			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);
941
942
		size_t write_bytes = min(count, nrptrs *
					(size_t)PAGE_CACHE_SIZE -
943
					 offset);
Chris Mason's avatar
Chris Mason committed
944
945
946
		size_t num_pages = (write_bytes + PAGE_CACHE_SIZE - 1) >>
					PAGE_CACHE_SHIFT;

947
		WARN_ON(num_pages > nrptrs);
Chris Mason's avatar
Chris Mason committed
948
		memset(pages, 0, sizeof(pages));
949
950
951
952
953

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

Chris Mason's avatar
Chris Mason committed
954
955
		ret = prepare_pages(root, file, pages, num_pages,
				    pos, first_index, last_index,
956
				    write_bytes);
957
958
		if (ret)
			goto out;
Chris Mason's avatar
Chris Mason committed
959
960
961

		ret = btrfs_copy_from_user(pos, num_pages,
					   write_bytes, pages, buf);
962
963
964
965
		if (ret) {
			btrfs_drop_pages(pages, num_pages);
			goto out;
		}
Chris Mason's avatar
Chris Mason committed
966
967
968
969

		ret = dirty_and_release_pages(NULL, root, file, pages,
					      num_pages, pos, write_bytes);
		btrfs_drop_pages(pages, num_pages);
970
971
		if (ret)
			goto out;
Chris Mason's avatar
Chris Mason committed
972
973
974
975
976
977

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

978
		balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
979
980
		if (num_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
			btrfs_btree_balance_dirty(root, 1);
981
		btrfs_throttle(root);
Chris Mason's avatar
Chris Mason committed
982
983
984
		cond_resched();
	}
out:
985
	mutex_unlock(&inode->i_mutex);
986

987
out_nolock:
988
	kfree(pages);
Chris Mason's avatar
Chris Mason committed
989
990
991
992
993
	if (pinned[0])
		page_cache_release(pinned[0]);
	if (pinned[1])
		page_cache_release(pinned[1]);
	*ppos = pos;
994
995
996
997
998
999

	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;
1000
	} else if (num_written > 0 && (file->f_flags & O_DIRECT)) {
For faster browsing, not all history is shown. View entire blame