file-item.c 11.5 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 20 21
#include <linux/bio.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
C
Chris Mason 已提交
22
#include "ctree.h"
C
Chris Mason 已提交
23
#include "disk-io.h"
24
#include "transaction.h"
C
Chris Mason 已提交
25
#include "print-tree.h"
C
Chris Mason 已提交
26

27
#define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \
28 29
			       sizeof(struct btrfs_item) * 2) / \
			       BTRFS_CRC32_SIZE) - 1))
C
Chris Mason 已提交
30
int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
S
Sage Weil 已提交
31 32 33 34
			     struct btrfs_root *root,
			     u64 objectid, u64 pos,
			     u64 disk_offset, u64 disk_num_bytes,
			     u64 num_bytes, u64 offset)
35
{
C
Chris Mason 已提交
36 37 38
	int ret = 0;
	struct btrfs_file_extent_item *item;
	struct btrfs_key file_key;
39
	struct btrfs_path *path;
40
	struct extent_buffer *leaf;
C
Chris Mason 已提交
41

42 43
	path = btrfs_alloc_path();
	BUG_ON(!path);
C
Chris Mason 已提交
44
	file_key.objectid = objectid;
C
Chris Mason 已提交
45
	file_key.offset = pos;
C
Chris Mason 已提交
46 47
	btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);

48
	ret = btrfs_insert_empty_item(trans, root, path, &file_key,
C
Chris Mason 已提交
49
				      sizeof(*item));
50 51
	if (ret < 0)
		goto out;
C
Chris Mason 已提交
52
	BUG_ON(ret);
53 54
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
55
			      struct btrfs_file_extent_item);
S
Sage Weil 已提交
56
	btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
57
	btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
S
Sage Weil 已提交
58
	btrfs_set_file_extent_offset(leaf, item, offset);
59
	btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
60 61 62
	btrfs_set_file_extent_generation(leaf, item, trans->transid);
	btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
	btrfs_mark_buffer_dirty(leaf);
63
out:
64
	btrfs_free_path(path);
65
	return ret;
66
}
C
Chris Mason 已提交
67

C
Chris Mason 已提交
68 69 70 71 72
struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path,
					  u64 objectid, u64 offset,
					  int cow)
73 74 75 76 77
{
	int ret;
	struct btrfs_key file_key;
	struct btrfs_key found_key;
	struct btrfs_csum_item *item;
78
	struct extent_buffer *leaf;
79
	u64 csum_offset = 0;
80
	int csums_in_item;
81 82 83 84

	file_key.objectid = objectid;
	file_key.offset = offset;
	btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
C
Chris Mason 已提交
85
	ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
86 87
	if (ret < 0)
		goto fail;
88
	leaf = path->nodes[0];
89 90
	if (ret > 0) {
		ret = 1;
91
		if (path->slots[0] == 0)
92 93
			goto fail;
		path->slots[0]--;
94
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
95 96 97 98 99 100
		if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
		    found_key.objectid != objectid) {
			goto fail;
		}
		csum_offset = (offset - found_key.offset) >>
				root->fs_info->sb->s_blocksize_bits;
101
		csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
102
		csums_in_item /= BTRFS_CRC32_SIZE;
103 104 105

		if (csum_offset >= csums_in_item) {
			ret = -EFBIG;
106 107 108 109
			goto fail;
		}
	}
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
110 111
	item = (struct btrfs_csum_item *)((unsigned char *)item +
					  csum_offset * BTRFS_CRC32_SIZE);
112 113 114
	return item;
fail:
	if (ret > 0)
C
Chris Mason 已提交
115
		ret = -ENOENT;
116 117 118 119
	return ERR_PTR(ret);
}


C
Chris Mason 已提交
120 121 122
int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid,
C
Chris Mason 已提交
123
			     u64 offset, int mod)
C
Chris Mason 已提交
124 125 126 127 128 129 130
{
	int ret;
	struct btrfs_key file_key;
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;

	file_key.objectid = objectid;
131
	file_key.offset = offset;
C
Chris Mason 已提交
132 133 134 135
	btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
	ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
	return ret;
}
C
Chris Mason 已提交
136

137 138
int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
		       struct bio *bio)
139
{
140 141
	struct btrfs_ordered_sum *sums;
	struct btrfs_sector_sum *sector_sum;
142
	struct btrfs_ordered_extent *ordered;
143 144 145
	char *data;
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
146 147 148
	unsigned long total_bytes = 0;
	unsigned long this_sum_bytes = 0;
	u64 offset;
149

150 151
	WARN_ON(bio->bi_vcnt <= 0);
	sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_size), GFP_NOFS);
152 153
	if (!sums)
		return -ENOMEM;
154

155
	sector_sum = sums->sums;
156
	sums->file_offset = page_offset(bvec->bv_page) + bvec->bv_offset;
157 158
	sums->len = bio->bi_size;
	INIT_LIST_HEAD(&sums->list);
159 160
	ordered = btrfs_lookup_ordered_extent(inode, sums->file_offset);
	BUG_ON(!ordered);
161 162

	while(bio_index < bio->bi_vcnt) {
163
		offset = page_offset(bvec->bv_page) + bvec->bv_offset;
164 165
		if (offset >= ordered->file_offset + ordered->len ||
		    offset < ordered->file_offset) {
166 167 168 169 170 171 172 173 174 175 176
			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);

			bytes_left = bio->bi_size - total_bytes;

			sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left),
				       GFP_NOFS);
			BUG_ON(!sums);
177
			sector_sum = sums->sums;
178 179 180 181 182 183 184
			sums->len = bytes_left;
			sums->file_offset = offset;
			ordered = btrfs_lookup_ordered_extent(inode,
						      sums->file_offset);
			BUG_ON(!ordered);
		}

185
		data = kmap_atomic(bvec->bv_page, KM_USER0);
186 187 188 189 190
		sector_sum->sum = ~(u32)0;
		sector_sum->sum = btrfs_csum_data(root,
						  data + bvec->bv_offset,
						  sector_sum->sum,
						  bvec->bv_len);
191
		kunmap_atomic(data, KM_USER0);
192 193 194 195
		btrfs_csum_final(sector_sum->sum,
				 (char *)&sector_sum->sum);
		sector_sum->offset = page_offset(bvec->bv_page) +
			bvec->bv_offset;
196

197
		sector_sum++;
198
		bio_index++;
199 200
		total_bytes += bvec->bv_len;
		this_sum_bytes += bvec->bv_len;
201 202
		bvec++;
	}
203
	this_sum_bytes = 0;
204 205
	btrfs_add_ordered_sum(inode, ordered, sums);
	btrfs_put_ordered_extent(ordered);
206 207 208
	return 0;
}

209 210
int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
			   struct btrfs_root *root, struct inode *inode,
211
			   struct btrfs_ordered_sum *sums)
C
Chris Mason 已提交
212
{
213 214
	u64 objectid = inode->i_ino;
	u64 offset;
C
Chris Mason 已提交
215 216
	int ret;
	struct btrfs_key file_key;
217
	struct btrfs_key found_key;
218
	u64 next_offset;
219
	u64 total_bytes = 0;
220
	int found_next;
221
	struct btrfs_path *path;
C
Chris Mason 已提交
222
	struct btrfs_csum_item *item;
223
	struct btrfs_csum_item *item_end;
224
	struct extent_buffer *leaf = NULL;
225
	u64 csum_offset;
226
	struct btrfs_sector_sum *sector_sum;
227 228
	u32 nritems;
	u32 ins_size;
229 230 231 232 233
	char *eb_map;
	char *eb_token;
	unsigned long map_len;
	unsigned long map_start;

234 235
	path = btrfs_alloc_path();
	BUG_ON(!path);
236
	sector_sum = sums->sums;
237 238 239
again:
	next_offset = (u64)-1;
	found_next = 0;
240
	offset = sector_sum->offset;
C
Chris Mason 已提交
241 242 243
	file_key.objectid = objectid;
	file_key.offset = offset;
	btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
244 245

	item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
246 247
	if (!IS_ERR(item)) {
		leaf = path->nodes[0];
248
		goto found;
249
	}
250 251 252 253
	ret = PTR_ERR(item);
	if (ret == -EFBIG) {
		u32 item_size;
		/* we found one, but it isn't big enough yet */
254 255
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
256
		if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) {
257 258 259 260
			/* already at max size, make a new one */
			goto insert;
		}
	} else {
261
		int slot = path->slots[0] + 1;
262
		/* we didn't find a csum item, insert one */
263 264 265
		nritems = btrfs_header_nritems(path->nodes[0]);
		if (path->slots[0] >= nritems - 1) {
			ret = btrfs_next_leaf(root, path);
Y
Yan 已提交
266
			if (ret == 1)
267
				found_next = 1;
Y
Yan 已提交
268
			if (ret != 0)
269
				goto insert;
Y
Yan 已提交
270
			slot = 0;
271 272 273 274 275 276 277 278 279
		}
		btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
		if (found_key.objectid != objectid ||
		    found_key.type != BTRFS_CSUM_ITEM_KEY) {
			found_next = 1;
			goto insert;
		}
		next_offset = found_key.offset;
		found_next = 1;
280 281 282 283 284 285 286 287
		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
	 */
	btrfs_release_path(root, path);
288
	ret = btrfs_search_slot(trans, root, &file_key, path,
289
				BTRFS_CRC32_SIZE, 1);
290 291 292
	if (ret < 0)
		goto fail;
	if (ret == 0) {
C
Chris Mason 已提交
293
		BUG();
294 295 296 297 298
	}
	if (path->slots[0] == 0) {
		goto insert;
	}
	path->slots[0]--;
299 300
	leaf = path->nodes[0];
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
301 302 303 304 305 306 307
	csum_offset = (offset - found_key.offset) >>
			root->fs_info->sb->s_blocksize_bits;
	if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
	    found_key.objectid != objectid ||
	    csum_offset >= MAX_CSUM_ITEMS(root)) {
		goto insert;
	}
308
	if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
309 310
	    BTRFS_CRC32_SIZE) {
		u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE;
311
		diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
C
Chris Mason 已提交
312 313
		if (diff != BTRFS_CRC32_SIZE)
			goto insert;
314
		ret = btrfs_extend_item(trans, root, path, diff);
315 316 317 318 319
		BUG_ON(ret);
		goto csum;
	}

insert:
320
	btrfs_release_path(root, path);
321
	csum_offset = 0;
322 323
	if (found_next) {
		u64 tmp = min((u64)i_size_read(inode), next_offset);
Y
Yan 已提交
324
		tmp -= offset & ~((u64)root->sectorsize -1);
325 326 327 328 329 330 331
		tmp >>= root->fs_info->sb->s_blocksize_bits;
		tmp = max((u64)1, tmp);
		tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root));
		ins_size = BTRFS_CRC32_SIZE * tmp;
	} else {
		ins_size = BTRFS_CRC32_SIZE;
	}
332
	ret = btrfs_insert_empty_item(trans, root, path, &file_key,
333
				      ins_size);
334 335
	if (ret < 0)
		goto fail;
336 337
	if (ret != 0) {
		WARN_ON(1);
C
Chris Mason 已提交
338
		goto fail;
339
	}
340
csum:
341 342
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
C
Chris Mason 已提交
343
	ret = 0;
344 345
	item = (struct btrfs_csum_item *)((unsigned char *)item +
					  csum_offset * BTRFS_CRC32_SIZE);
C
Chris Mason 已提交
346
found:
347 348 349
	item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
	item_end = (struct btrfs_csum_item *)((unsigned char *)item_end +
				      btrfs_item_size_nr(leaf, path->slots[0]));
350
	eb_token = NULL;
351
next_sector:
352

353 354 355 356 357
	if (!eb_token ||
	   (unsigned long)item  + BTRFS_CRC32_SIZE >= map_start + map_len) {
		int err;

		if (eb_token)
358
			unmap_extent_buffer(leaf, eb_token, KM_USER1);
359 360 361 362
		eb_token = NULL;
		err = map_private_extent_buffer(leaf, (unsigned long)item,
						BTRFS_CRC32_SIZE,
						&eb_token, &eb_map,
363
						&map_start, &map_len, KM_USER1);
364 365 366 367 368
		if (err)
			eb_token = NULL;
	}
	if (eb_token) {
		memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)),
369
		       &sector_sum->sum, BTRFS_CRC32_SIZE);
370
	} else {
371 372
		write_extent_buffer(leaf, &sector_sum->sum,
				    (unsigned long)item, BTRFS_CRC32_SIZE);
373
	}
374

375 376 377
	total_bytes += root->sectorsize;
	sector_sum++;
	if (total_bytes < sums->len) {
378 379
		item = (struct btrfs_csum_item *)((char *)item +
						  BTRFS_CRC32_SIZE);
380
		if (item < item_end && offset + PAGE_CACHE_SIZE ==
381 382 383
		    sector_sum->offset) {
			    offset = sector_sum->offset;
			goto next_sector;
384
		}
385
	}
386
	if (eb_token) {
387
		unmap_extent_buffer(leaf, eb_token, KM_USER1);
388 389
		eb_token = NULL;
	}
390
	btrfs_mark_buffer_dirty(path->nodes[0]);
391
	if (total_bytes < sums->len) {
392 393 394
		btrfs_release_path(root, path);
		goto again;
	}
C
Chris Mason 已提交
395
fail:
396
	btrfs_free_path(path);
C
Chris Mason 已提交
397 398 399
	return ret;
}

C
Chris Mason 已提交
400 401 402 403 404
int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
			struct btrfs_root *root, struct btrfs_path *path,
			u64 isize)
{
	struct btrfs_key key;
405
	struct extent_buffer *leaf = path->nodes[0];
C
Chris Mason 已提交
406 407 408 409 410 411
	int slot = path->slots[0];
	int ret;
	u32 new_item_size;
	u64 new_item_span;
	u64 blocks;

412
	btrfs_item_key_to_cpu(leaf, &key, slot);
C
Chris Mason 已提交
413 414 415
	if (isize <= key.offset)
		return 0;
	new_item_span = isize - key.offset;
416
	blocks = (new_item_span + root->sectorsize - 1) >>
C
Chris Mason 已提交
417
		root->fs_info->sb->s_blocksize_bits;
C
Chris Mason 已提交
418
	new_item_size = blocks * BTRFS_CRC32_SIZE;
419
	if (new_item_size >= btrfs_item_size_nr(leaf, slot))
C
Chris Mason 已提交
420
		return 0;
421
	ret = btrfs_truncate_item(trans, root, path, new_item_size, 1);
C
Chris Mason 已提交
422 423 424
	BUG_ON(ret);
	return ret;
}