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

19
#include <linux/bio.h>
20
#include <linux/slab.h>
21 22
#include <linux/pagemap.h>
#include <linux/highmem.h>
C
Chris Mason 已提交
23
#include "ctree.h"
C
Chris Mason 已提交
24
#include "disk-io.h"
25
#include "transaction.h"
26
#include "volumes.h"
C
Chris Mason 已提交
27
#include "print-tree.h"
C
Chris Mason 已提交
28

29
#define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
30 31
				   sizeof(struct btrfs_item) * 2) / \
				  size) - 1))
Y
Yan Zheng 已提交
32

33 34
#define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
				       PAGE_CACHE_SIZE))
35

Y
Yan Zheng 已提交
36 37
#define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \
				   sizeof(struct btrfs_ordered_sum)) / \
38
				   sizeof(u32) * (r)->sectorsize)
Y
Yan Zheng 已提交
39

C
Chris Mason 已提交
40
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
S
Sage Weil 已提交
41 42 43
			     struct btrfs_root *root,
			     u64 objectid, u64 pos,
			     u64 disk_offset, u64 disk_num_bytes,
C
Chris Mason 已提交
44 45
			     u64 num_bytes, u64 offset, u64 ram_bytes,
			     u8 compression, u8 encryption, u16 other_encoding)
46
{
C
Chris Mason 已提交
47 48 49
	int ret = 0;
	struct btrfs_file_extent_item *item;
	struct btrfs_key file_key;
50
	struct btrfs_path *path;
51
	struct extent_buffer *leaf;
C
Chris Mason 已提交
52

53
	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
54 55
	if (!path)
		return -ENOMEM;
C
Chris Mason 已提交
56
	file_key.objectid = objectid;
C
Chris Mason 已提交
57
	file_key.offset = pos;
58
	file_key.type = BTRFS_EXTENT_DATA_KEY;
C
Chris Mason 已提交
59

60
	path->leave_spinning = 1;
61
	ret = btrfs_insert_empty_item(trans, root, path, &file_key,
C
Chris Mason 已提交
62
				      sizeof(*item));
63 64
	if (ret < 0)
		goto out;
65
	BUG_ON(ret); /* Can't happen */
66 67
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
68
			      struct btrfs_file_extent_item);
S
Sage Weil 已提交
69
	btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
70
	btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
S
Sage Weil 已提交
71
	btrfs_set_file_extent_offset(leaf, item, offset);
72
	btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
C
Chris Mason 已提交
73
	btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes);
74 75
	btrfs_set_file_extent_generation(leaf, item, trans->transid);
	btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
C
Chris Mason 已提交
76 77 78 79
	btrfs_set_file_extent_compression(leaf, item, compression);
	btrfs_set_file_extent_encryption(leaf, item, encryption);
	btrfs_set_file_extent_other_encoding(leaf, item, other_encoding);

80
	btrfs_mark_buffer_dirty(leaf);
81
out:
82
	btrfs_free_path(path);
83
	return ret;
84
}
C
Chris Mason 已提交
85

86 87 88 89 90
static struct btrfs_csum_item *
btrfs_lookup_csum(struct btrfs_trans_handle *trans,
		  struct btrfs_root *root,
		  struct btrfs_path *path,
		  u64 bytenr, int cow)
91 92 93 94 95
{
	int ret;
	struct btrfs_key file_key;
	struct btrfs_key found_key;
	struct btrfs_csum_item *item;
96
	struct extent_buffer *leaf;
97
	u64 csum_offset = 0;
98
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
99
	int csums_in_item;
100

101 102
	file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
	file_key.offset = bytenr;
103
	file_key.type = BTRFS_EXTENT_CSUM_KEY;
C
Chris Mason 已提交
104
	ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
105 106
	if (ret < 0)
		goto fail;
107
	leaf = path->nodes[0];
108 109
	if (ret > 0) {
		ret = 1;
110
		if (path->slots[0] == 0)
111 112
			goto fail;
		path->slots[0]--;
113
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
114
		if (found_key.type != BTRFS_EXTENT_CSUM_KEY)
115
			goto fail;
116 117

		csum_offset = (bytenr - found_key.offset) >>
118
				root->fs_info->sb->s_blocksize_bits;
119
		csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
120
		csums_in_item /= csum_size;
121

122
		if (csum_offset == csums_in_item) {
123
			ret = -EFBIG;
124
			goto fail;
125 126
		} else if (csum_offset > csums_in_item) {
			goto fail;
127 128 129
		}
	}
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
130
	item = (struct btrfs_csum_item *)((unsigned char *)item +
131
					  csum_offset * csum_size);
132 133 134
	return item;
fail:
	if (ret > 0)
C
Chris Mason 已提交
135
		ret = -ENOENT;
136 137 138
	return ERR_PTR(ret);
}

C
Chris Mason 已提交
139 140 141
int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid,
C
Chris Mason 已提交
142
			     u64 offset, int mod)
C
Chris Mason 已提交
143 144 145 146 147 148 149
{
	int ret;
	struct btrfs_key file_key;
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;

	file_key.objectid = objectid;
150
	file_key.offset = offset;
151
	file_key.type = BTRFS_EXTENT_DATA_KEY;
C
Chris Mason 已提交
152 153 154
	ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
	return ret;
}
C
Chris Mason 已提交
155

156 157 158 159 160
static void btrfs_io_bio_endio_readpage(struct btrfs_io_bio *bio, int err)
{
	kfree(bio->csum_allocated);
}

161 162 163
static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
				   struct inode *inode, struct bio *bio,
				   u64 logical_offset, u32 *dst, int dio)
164 165
{
	struct bio_vec *bvec = bio->bi_io_vec;
166 167 168 169 170
	struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio);
	struct btrfs_csum_item *item = NULL;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct btrfs_path *path;
	u8 *csum;
171
	u64 offset = 0;
172 173
	u64 item_start_offset = 0;
	u64 item_last_offset = 0;
174
	u64 disk_bytenr;
175
	u32 diff;
176 177
	int nblocks;
	int bio_index = 0;
178
	int count;
179
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
180 181

	path = btrfs_alloc_path();
182 183
	if (!path)
		return -ENOMEM;
184

185
	nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	if (!dst) {
		if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
			btrfs_bio->csum_allocated = kmalloc(nblocks * csum_size,
							    GFP_NOFS);
			if (!btrfs_bio->csum_allocated) {
				btrfs_free_path(path);
				return -ENOMEM;
			}
			btrfs_bio->csum = btrfs_bio->csum_allocated;
			btrfs_bio->end_io = btrfs_io_bio_endio_readpage;
		} else {
			btrfs_bio->csum = btrfs_bio->csum_inline;
		}
		csum = btrfs_bio->csum;
	} else {
		csum = (u8 *)dst;
	}

204
	if (bio->bi_iter.bi_size > PAGE_CACHE_SIZE * 8)
205
		path->reada = 2;
206 207 208

	WARN_ON(bio->bi_vcnt <= 0);

209 210 211 212 213 214
	/*
	 * the free space stuff is only read when it hasn't been
	 * updated in the current transaction.  So, we can safely
	 * read from the commit root and sidestep a nasty deadlock
	 * between reading the free space cache and updating the csum tree.
	 */
215
	if (btrfs_is_free_space_inode(inode)) {
216
		path->search_commit_root = 1;
217 218
		path->skip_locking = 1;
	}
219

220
	disk_bytenr = (u64)bio->bi_iter.bi_sector << 9;
221 222
	if (dio)
		offset = logical_offset;
C
Chris Mason 已提交
223
	while (bio_index < bio->bi_vcnt) {
224 225
		if (!dio)
			offset = page_offset(bvec->bv_page) + bvec->bv_offset;
226 227
		count = btrfs_find_ordered_sum(inode, offset, disk_bytenr,
					       (u32 *)csum, nblocks);
228
		if (count)
229 230
			goto found;

231 232
		if (!item || disk_bytenr < item_start_offset ||
		    disk_bytenr >= item_last_offset) {
233 234 235 236
			struct btrfs_key found_key;
			u32 item_size;

			if (item)
237
				btrfs_release_path(path);
238 239
			item = btrfs_lookup_csum(NULL, root->fs_info->csum_root,
						 path, disk_bytenr, 0);
240
			if (IS_ERR(item)) {
241
				count = 1;
242
				memset(csum, 0, csum_size);
243 244 245 246 247 248
				if (BTRFS_I(inode)->root->root_key.objectid ==
				    BTRFS_DATA_RELOC_TREE_OBJECTID) {
					set_extent_bits(io_tree, offset,
						offset + bvec->bv_len - 1,
						EXTENT_NODATASUM, GFP_NOFS);
				} else {
249 250
					btrfs_info(BTRFS_I(inode)->root->fs_info,
						   "no csum found for inode %llu start %llu",
251
					       btrfs_ino(inode), offset);
252
				}
253
				item = NULL;
254
				btrfs_release_path(path);
255 256 257 258 259 260 261 262 263
				goto found;
			}
			btrfs_item_key_to_cpu(path->nodes[0], &found_key,
					      path->slots[0]);

			item_start_offset = found_key.offset;
			item_size = btrfs_item_size_nr(path->nodes[0],
						       path->slots[0]);
			item_last_offset = item_start_offset +
264
				(item_size / csum_size) *
265 266 267 268 269 270 271 272
				root->sectorsize;
			item = btrfs_item_ptr(path->nodes[0], path->slots[0],
					      struct btrfs_csum_item);
		}
		/*
		 * this byte range must be able to fit inside
		 * a single leaf so it will also fit inside a u32
		 */
273
		diff = disk_bytenr - item_start_offset;
274
		diff = diff / root->sectorsize;
275
		diff = diff * csum_size;
276 277 278
		count = min_t(int, nblocks, (item_last_offset - disk_bytenr) >>
					    inode->i_sb->s_blocksize_bits);
		read_extent_buffer(path->nodes[0], csum,
279
				   ((unsigned long)item) + diff,
280
				   csum_size * count);
281
found:
282 283
		csum += count * csum_size;
		nblocks -= count;
284
		bio_index += count;
285 286 287 288 289
		while (count--) {
			disk_bytenr += bvec->bv_len;
			offset += bvec->bv_len;
			bvec++;
		}
290 291 292 293 294
	}
	btrfs_free_path(path);
	return 0;
}

295 296 297 298 299 300 301
int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
			  struct bio *bio, u32 *dst)
{
	return __btrfs_lookup_bio_sums(root, inode, bio, 0, dst, 0);
}

int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
302 303
			      struct btrfs_dio_private *dip, struct bio *bio,
			      u64 offset)
304
{
305
	int len = (bio->bi_iter.bi_sector << 9) - dip->disk_bytenr;
306 307 308 309 310 311 312 313 314
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
	int ret;

	len >>= inode->i_sb->s_blocksize_bits;
	len *= csum_size;

	ret = __btrfs_lookup_bio_sums(root, inode, bio, offset,
				      (u32 *)(dip->csum + len), 1);
	return ret;
315 316
}

317
int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
A
Arne Jansen 已提交
318
			     struct list_head *list, int search_commit)
319 320 321 322 323 324
{
	struct btrfs_key key;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_ordered_sum *sums;
	struct btrfs_csum_item *item;
325
	LIST_HEAD(tmplist);
326 327 328 329
	unsigned long offset;
	int ret;
	size_t size;
	u64 csum_end;
330
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
331

332 333 334
	ASSERT(start == ALIGN(start, root->sectorsize) &&
	       (end + 1) == ALIGN(end + 1, root->sectorsize));

335
	path = btrfs_alloc_path();
336 337
	if (!path)
		return -ENOMEM;
338

A
Arne Jansen 已提交
339 340 341 342 343 344
	if (search_commit) {
		path->skip_locking = 1;
		path->reada = 2;
		path->search_commit_root = 1;
	}

345 346 347 348
	key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
	key.offset = start;
	key.type = BTRFS_EXTENT_CSUM_KEY;

Y
Yan Zheng 已提交
349
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
	if (ret < 0)
		goto fail;
	if (ret > 0 && path->slots[0] > 0) {
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
		if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
		    key.type == BTRFS_EXTENT_CSUM_KEY) {
			offset = (start - key.offset) >>
				 root->fs_info->sb->s_blocksize_bits;
			if (offset * csum_size <
			    btrfs_item_size_nr(leaf, path->slots[0] - 1))
				path->slots[0]--;
		}
	}

	while (start <= end) {
		leaf = path->nodes[0];
		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
Y
Yan Zheng 已提交
368
			ret = btrfs_next_leaf(root, path);
369 370 371 372 373 374 375 376 377
			if (ret < 0)
				goto fail;
			if (ret > 0)
				break;
			leaf = path->nodes[0];
		}

		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
		if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
378 379
		    key.type != BTRFS_EXTENT_CSUM_KEY ||
		    key.offset > end)
380 381 382 383 384 385 386
			break;

		if (key.offset > start)
			start = key.offset;

		size = btrfs_item_size_nr(leaf, path->slots[0]);
		csum_end = key.offset + (size / csum_size) * root->sectorsize;
387 388 389 390
		if (csum_end <= start) {
			path->slots[0]++;
			continue;
		}
391

Y
Yan Zheng 已提交
392
		csum_end = min(csum_end, end + 1);
393 394
		item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				      struct btrfs_csum_item);
Y
Yan Zheng 已提交
395 396
		while (start < csum_end) {
			size = min_t(size_t, csum_end - start,
397
				     MAX_ORDERED_SUM_BYTES(root));
Y
Yan Zheng 已提交
398
			sums = kzalloc(btrfs_ordered_sum_size(root, size),
399
				       GFP_NOFS);
400 401 402 403
			if (!sums) {
				ret = -ENOMEM;
				goto fail;
			}
404

Y
Yan Zheng 已提交
405
			sums->bytenr = start;
406
			sums->len = (int)size;
Y
Yan Zheng 已提交
407 408 409 410

			offset = (start - key.offset) >>
				root->fs_info->sb->s_blocksize_bits;
			offset *= csum_size;
411
			size >>= root->fs_info->sb->s_blocksize_bits;
Y
Yan Zheng 已提交
412

413 414 415 416 417 418
			read_extent_buffer(path->nodes[0],
					   sums->sums,
					   ((unsigned long)item) + offset,
					   csum_size * size);

			start += root->sectorsize * size;
419
			list_add_tail(&sums->list, &tmplist);
Y
Yan Zheng 已提交
420
		}
421 422 423 424
		path->slots[0]++;
	}
	ret = 0;
fail:
425 426 427 428 429 430 431
	while (ret < 0 && !list_empty(&tmplist)) {
		sums = list_entry(&tmplist, struct btrfs_ordered_sum, list);
		list_del(&sums->list);
		kfree(sums);
	}
	list_splice_tail(&tmplist, list);

432 433 434 435
	btrfs_free_path(path);
	return ret;
}

436
int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
437
		       struct bio *bio, u64 file_start, int contig)
438
{
439
	struct btrfs_ordered_sum *sums;
440
	struct btrfs_ordered_extent *ordered;
441 442 443
	char *data;
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
444
	int index;
445 446 447
	unsigned long total_bytes = 0;
	unsigned long this_sum_bytes = 0;
	u64 offset;
448

449
	WARN_ON(bio->bi_vcnt <= 0);
450 451
	sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_iter.bi_size),
		       GFP_NOFS);
452 453
	if (!sums)
		return -ENOMEM;
454

455
	sums->len = bio->bi_iter.bi_size;
456
	INIT_LIST_HEAD(&sums->list);
457 458 459 460 461 462 463

	if (contig)
		offset = file_start;
	else
		offset = page_offset(bvec->bv_page) + bvec->bv_offset;

	ordered = btrfs_lookup_ordered_extent(inode, offset);
464
	BUG_ON(!ordered); /* Logic error */
465
	sums->bytenr = (u64)bio->bi_iter.bi_sector << 9;
466
	index = 0;
467

C
Chris Mason 已提交
468
	while (bio_index < bio->bi_vcnt) {
469 470 471
		if (!contig)
			offset = page_offset(bvec->bv_page) + bvec->bv_offset;

472 473
		if (offset >= ordered->file_offset + ordered->len ||
		    offset < ordered->file_offset) {
474 475 476 477 478 479
			unsigned long bytes_left;
			sums->len = this_sum_bytes;
			this_sum_bytes = 0;
			btrfs_add_ordered_sum(inode, ordered, sums);
			btrfs_put_ordered_extent(ordered);

480
			bytes_left = bio->bi_iter.bi_size - total_bytes;
481 482 483

			sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left),
				       GFP_NOFS);
484
			BUG_ON(!sums); /* -ENOMEM */
485
			sums->len = bytes_left;
486
			ordered = btrfs_lookup_ordered_extent(inode, offset);
487
			BUG_ON(!ordered); /* Logic error */
488
			sums->bytenr = ((u64)bio->bi_iter.bi_sector << 9) +
489 490
				       total_bytes;
			index = 0;
491 492
		}

493
		data = kmap_atomic(bvec->bv_page);
494 495 496 497
		sums->sums[index] = ~(u32)0;
		sums->sums[index] = btrfs_csum_data(data + bvec->bv_offset,
						    sums->sums[index],
						    bvec->bv_len);
498
		kunmap_atomic(data);
499 500
		btrfs_csum_final(sums->sums[index],
				 (char *)(sums->sums + index));
501

502
		bio_index++;
503
		index++;
504 505
		total_bytes += bvec->bv_len;
		this_sum_bytes += bvec->bv_len;
506
		offset += bvec->bv_len;
507 508
		bvec++;
	}
509
	this_sum_bytes = 0;
510 511
	btrfs_add_ordered_sum(inode, ordered, sums);
	btrfs_put_ordered_extent(ordered);
512 513 514
	return 0;
}

515 516 517 518 519 520 521 522 523 524 525
/*
 * helper function for csum removal, this expects the
 * key to describe the csum pointed to by the path, and it expects
 * the csum to overlap the range [bytenr, len]
 *
 * The csum should not be entirely contained in the range and the
 * range should not be entirely contained in the csum.
 *
 * This calls btrfs_truncate_item with the correct args based on the
 * overlap, and fixes up the key as required.
 */
526
static noinline void truncate_one_csum(struct btrfs_root *root,
527 528 529
				       struct btrfs_path *path,
				       struct btrfs_key *key,
				       u64 bytenr, u64 len)
530 531
{
	struct extent_buffer *leaf;
532
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
	u64 csum_end;
	u64 end_byte = bytenr + len;
	u32 blocksize_bits = root->fs_info->sb->s_blocksize_bits;

	leaf = path->nodes[0];
	csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
	csum_end <<= root->fs_info->sb->s_blocksize_bits;
	csum_end += key->offset;

	if (key->offset < bytenr && csum_end <= end_byte) {
		/*
		 *         [ bytenr - len ]
		 *         [   ]
		 *   [csum     ]
		 *   A simple truncate off the end of the item
		 */
		u32 new_size = (bytenr - key->offset) >> blocksize_bits;
		new_size *= csum_size;
551
		btrfs_truncate_item(root, path, new_size, 1);
552 553 554 555 556 557 558 559 560 561 562
	} else if (key->offset >= bytenr && csum_end > end_byte &&
		   end_byte > key->offset) {
		/*
		 *         [ bytenr - len ]
		 *                 [ ]
		 *                 [csum     ]
		 * we need to truncate from the beginning of the csum
		 */
		u32 new_size = (csum_end - end_byte) >> blocksize_bits;
		new_size *= csum_size;

563
		btrfs_truncate_item(root, path, new_size, 0);
564 565

		key->offset = end_byte;
566
		btrfs_set_item_key_safe(root, path, key);
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
	} else {
		BUG();
	}
}

/*
 * deletes the csum items from the csum tree for a given
 * range of bytes.
 */
int btrfs_del_csums(struct btrfs_trans_handle *trans,
		    struct btrfs_root *root, u64 bytenr, u64 len)
{
	struct btrfs_path *path;
	struct btrfs_key key;
	u64 end_byte = bytenr + len;
	u64 csum_end;
	struct extent_buffer *leaf;
	int ret;
585
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
586 587 588 589 590
	int blocksize_bits = root->fs_info->sb->s_blocksize_bits;

	root = root->fs_info->csum_root;

	path = btrfs_alloc_path();
591 592
	if (!path)
		return -ENOMEM;
593

C
Chris Mason 已提交
594
	while (1) {
595 596 597 598
		key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
		key.offset = end_byte - 1;
		key.type = BTRFS_EXTENT_CSUM_KEY;

599
		path->leave_spinning = 1;
600 601 602
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret > 0) {
			if (path->slots[0] == 0)
603
				break;
604
			path->slots[0]--;
605
		} else if (ret < 0) {
606
			break;
607
		}
608

609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);

		if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
		    key.type != BTRFS_EXTENT_CSUM_KEY) {
			break;
		}

		if (key.offset >= end_byte)
			break;

		csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
		csum_end <<= blocksize_bits;
		csum_end += key.offset;

		/* this csum ends before we start, we're done */
		if (csum_end <= bytenr)
			break;

		/* delete the entire item, it is inside our range */
		if (key.offset >= bytenr && csum_end <= end_byte) {
			ret = btrfs_del_item(trans, root, path);
631 632
			if (ret)
				goto out;
633 634
			if (key.offset == bytenr)
				break;
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
		} else if (key.offset < bytenr && csum_end > end_byte) {
			unsigned long offset;
			unsigned long shift_len;
			unsigned long item_offset;
			/*
			 *        [ bytenr - len ]
			 *     [csum                ]
			 *
			 * Our bytes are in the middle of the csum,
			 * we need to split this item and insert a new one.
			 *
			 * But we can't drop the path because the
			 * csum could change, get removed, extended etc.
			 *
			 * The trick here is the max size of a csum item leaves
			 * enough room in the tree block for a single
			 * item header.  So, we split the item in place,
			 * adding a new header pointing to the existing
			 * bytes.  Then we loop around again and we have
			 * a nicely formed csum item that we can neatly
			 * truncate.
			 */
			offset = (bytenr - key.offset) >> blocksize_bits;
			offset *= csum_size;

			shift_len = (len >> blocksize_bits) * csum_size;

			item_offset = btrfs_item_ptr_offset(leaf,
							    path->slots[0]);

			memset_extent_buffer(leaf, 0, item_offset + offset,
					     shift_len);
			key.offset = bytenr;

			/*
			 * btrfs_split_item returns -EAGAIN when the
			 * item changed size or key
			 */
			ret = btrfs_split_item(trans, root, path, &key, offset);
674 675 676 677
			if (ret && ret != -EAGAIN) {
				btrfs_abort_transaction(trans, root, ret);
				goto out;
			}
678 679 680

			key.offset = end_byte - 1;
		} else {
681
			truncate_one_csum(root, path, &key, bytenr, len);
682 683
			if (key.offset < bytenr)
				break;
684
		}
685
		btrfs_release_path(path);
686
	}
687
	ret = 0;
688 689
out:
	btrfs_free_path(path);
690
	return ret;
691 692
}

693
int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
694
			   struct btrfs_root *root,
695
			   struct btrfs_ordered_sum *sums)
C
Chris Mason 已提交
696 697
{
	struct btrfs_key file_key;
698
	struct btrfs_key found_key;
699
	struct btrfs_path *path;
C
Chris Mason 已提交
700
	struct btrfs_csum_item *item;
701
	struct btrfs_csum_item *item_end;
702
	struct extent_buffer *leaf = NULL;
703 704
	u64 next_offset;
	u64 total_bytes = 0;
705
	u64 csum_offset;
706
	u64 bytenr;
707 708
	u32 nritems;
	u32 ins_size;
709 710 711
	int index = 0;
	int found_next;
	int ret;
712
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
713

714
	path = btrfs_alloc_path();
715 716
	if (!path)
		return -ENOMEM;
717 718 719
again:
	next_offset = (u64)-1;
	found_next = 0;
720
	bytenr = sums->bytenr + total_bytes;
721
	file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
722
	file_key.offset = bytenr;
723
	file_key.type = BTRFS_EXTENT_CSUM_KEY;
724

725
	item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
726
	if (!IS_ERR(item)) {
727
		ret = 0;
728 729 730 731 732
		leaf = path->nodes[0];
		item_end = btrfs_item_ptr(leaf, path->slots[0],
					  struct btrfs_csum_item);
		item_end = (struct btrfs_csum_item *)((char *)item_end +
			   btrfs_item_size_nr(leaf, path->slots[0]));
733
		goto found;
734
	}
735
	ret = PTR_ERR(item);
736 737 738
	if (ret != -EFBIG && ret != -ENOENT)
		goto fail_unlock;

739 740 741
	if (ret == -EFBIG) {
		u32 item_size;
		/* we found one, but it isn't big enough yet */
742 743
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
744 745
		if ((item_size / csum_size) >=
		    MAX_CSUM_ITEMS(root, csum_size)) {
746 747 748 749
			/* already at max size, make a new one */
			goto insert;
		}
	} else {
750
		int slot = path->slots[0] + 1;
751
		/* we didn't find a csum item, insert one */
752
		nritems = btrfs_header_nritems(path->nodes[0]);
753
		if (!nritems || (path->slots[0] >= nritems - 1)) {
754
			ret = btrfs_next_leaf(root, path);
Y
Yan 已提交
755
			if (ret == 1)
756
				found_next = 1;
Y
Yan 已提交
757
			if (ret != 0)
758
				goto insert;
759
			slot = path->slots[0];
760 761
		}
		btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
762 763
		if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
		    found_key.type != BTRFS_EXTENT_CSUM_KEY) {
764 765 766 767 768
			found_next = 1;
			goto insert;
		}
		next_offset = found_key.offset;
		found_next = 1;
769 770 771 772 773 774 775
		goto insert;
	}

	/*
	 * at this point, we know the tree has an item, but it isn't big
	 * enough yet to put our csum in.  Grow it
	 */
776
	btrfs_release_path(path);
777
	ret = btrfs_search_slot(trans, root, &file_key, path,
778
				csum_size, 1);
779
	if (ret < 0)
780
		goto fail_unlock;
781 782 783 784 785

	if (ret > 0) {
		if (path->slots[0] == 0)
			goto insert;
		path->slots[0]--;
786
	}
787

788 789
	leaf = path->nodes[0];
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
790
	csum_offset = (bytenr - found_key.offset) >>
791
			root->fs_info->sb->s_blocksize_bits;
792

793
	if (found_key.type != BTRFS_EXTENT_CSUM_KEY ||
794
	    found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
795
	    csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
796 797
		goto insert;
	}
798

799
	if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) /
800
	    csum_size) {
801 802 803 804
		int extend_nr;
		u64 tmp;
		u32 diff;
		u32 free_space;
805

806 807 808 809 810 811
		if (btrfs_leaf_free_space(root, leaf) <
				 sizeof(struct btrfs_item) + csum_size * 2)
			goto insert;

		free_space = btrfs_leaf_free_space(root, leaf) -
					 sizeof(struct btrfs_item) - csum_size;
812
		tmp = sums->len - total_bytes;
813 814 815 816 817 818
		tmp >>= root->fs_info->sb->s_blocksize_bits;
		WARN_ON(tmp < 1);

		extend_nr = max_t(int, 1, (int)tmp);
		diff = (csum_offset + extend_nr) * csum_size;
		diff = min(diff, MAX_CSUM_ITEMS(root, csum_size) * csum_size);
819

820
		diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
821 822 823
		diff = min(free_space, diff);
		diff /= csum_size;
		diff *= csum_size;
824

825
		btrfs_extend_item(root, path, diff);
826
		ret = 0;
827 828 829 830
		goto csum;
	}

insert:
831
	btrfs_release_path(path);
832
	csum_offset = 0;
833
	if (found_next) {
834
		u64 tmp;
835

836
		tmp = sums->len - total_bytes;
837
		tmp >>= root->fs_info->sb->s_blocksize_bits;
838 839 840
		tmp = min(tmp, (next_offset - file_key.offset) >>
					 root->fs_info->sb->s_blocksize_bits);

841
		tmp = max((u64)1, tmp);
842 843
		tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size));
		ins_size = csum_size * tmp;
844
	} else {
845
		ins_size = csum_size;
846
	}
847
	path->leave_spinning = 1;
848
	ret = btrfs_insert_empty_item(trans, root, path, &file_key,
849
				      ins_size);
850
	path->leave_spinning = 0;
851
	if (ret < 0)
852
		goto fail_unlock;
853
	if (WARN_ON(ret != 0))
854
		goto fail_unlock;
855
	leaf = path->nodes[0];
856
csum:
857
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
858 859
	item_end = (struct btrfs_csum_item *)((unsigned char *)item +
				      btrfs_item_size_nr(leaf, path->slots[0]));
860
	item = (struct btrfs_csum_item *)((unsigned char *)item +
861
					  csum_offset * csum_size);
C
Chris Mason 已提交
862
found:
863 864 865 866 867 868 869 870 871 872 873
	ins_size = (u32)(sums->len - total_bytes) >>
		   root->fs_info->sb->s_blocksize_bits;
	ins_size *= csum_size;
	ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item,
			      ins_size);
	write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,
			    ins_size);

	ins_size /= csum_size;
	total_bytes += ins_size * root->sectorsize;
	index += ins_size;
874

875
	btrfs_mark_buffer_dirty(path->nodes[0]);
876
	if (total_bytes < sums->len) {
877
		btrfs_release_path(path);
878
		cond_resched();
879 880
		goto again;
	}
881
out:
882
	btrfs_free_path(path);
C
Chris Mason 已提交
883
	return ret;
884 885 886

fail_unlock:
	goto out;
C
Chris Mason 已提交
887
}
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963

void btrfs_extent_item_to_extent_map(struct inode *inode,
				     const struct btrfs_path *path,
				     struct btrfs_file_extent_item *fi,
				     const bool new_inline,
				     struct extent_map *em)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_buffer *leaf = path->nodes[0];
	const int slot = path->slots[0];
	struct btrfs_key key;
	u64 extent_start, extent_end;
	u64 bytenr;
	u8 type = btrfs_file_extent_type(leaf, fi);
	int compress_type = btrfs_file_extent_compression(leaf, fi);

	em->bdev = root->fs_info->fs_devices->latest_bdev;
	btrfs_item_key_to_cpu(leaf, &key, slot);
	extent_start = key.offset;

	if (type == BTRFS_FILE_EXTENT_REG ||
	    type == BTRFS_FILE_EXTENT_PREALLOC) {
		extent_end = extent_start +
			btrfs_file_extent_num_bytes(leaf, fi);
	} else if (type == BTRFS_FILE_EXTENT_INLINE) {
		size_t size;
		size = btrfs_file_extent_inline_len(leaf, slot, fi);
		extent_end = ALIGN(extent_start + size, root->sectorsize);
	}

	em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
	if (type == BTRFS_FILE_EXTENT_REG ||
	    type == BTRFS_FILE_EXTENT_PREALLOC) {
		em->start = extent_start;
		em->len = extent_end - extent_start;
		em->orig_start = extent_start -
			btrfs_file_extent_offset(leaf, fi);
		em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
		bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
		if (bytenr == 0) {
			em->block_start = EXTENT_MAP_HOLE;
			return;
		}
		if (compress_type != BTRFS_COMPRESS_NONE) {
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
			em->compress_type = compress_type;
			em->block_start = bytenr;
			em->block_len = em->orig_block_len;
		} else {
			bytenr += btrfs_file_extent_offset(leaf, fi);
			em->block_start = bytenr;
			em->block_len = em->len;
			if (type == BTRFS_FILE_EXTENT_PREALLOC)
				set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
		}
	} else if (type == BTRFS_FILE_EXTENT_INLINE) {
		em->block_start = EXTENT_MAP_INLINE;
		em->start = extent_start;
		em->len = extent_end - extent_start;
		/*
		 * Initialize orig_start and block_len with the same values
		 * as in inode.c:btrfs_get_extent().
		 */
		em->orig_start = EXTENT_MAP_HOLE;
		em->block_len = (u64)-1;
		if (!new_inline && compress_type != BTRFS_COMPRESS_NONE) {
			set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
			em->compress_type = compress_type;
		}
	} else {
		btrfs_err(root->fs_info,
			  "unknown file extent item type %d, inode %llu, offset %llu, root %llu",
			  type, btrfs_ino(inode), extent_start,
			  root->root_key.objectid);
	}
}