inode.c 73.8 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 32
#include <linux/buffer_head.h>
#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>
C
Chris Mason 已提交
33
#include <linux/bit_spinlock.h>
34
#include <linux/version.h>
J
Josef Bacik 已提交
35
#include <linux/xattr.h>
C
Chris Mason 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"

struct btrfs_iget_args {
	u64 ino;
	struct btrfs_root *root;
};

static struct inode_operations btrfs_dir_inode_operations;
static struct inode_operations btrfs_symlink_inode_operations;
static struct inode_operations btrfs_dir_ro_inode_operations;
J
Josef Bacik 已提交
51
static struct inode_operations btrfs_special_inode_operations;
C
Chris Mason 已提交
52 53 54 55
static struct inode_operations btrfs_file_inode_operations;
static struct address_space_operations btrfs_aops;
static struct address_space_operations btrfs_symlink_aops;
static struct file_operations btrfs_dir_file_operations;
56
static struct extent_map_ops btrfs_extent_map_ops;
C
Chris Mason 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

static struct kmem_cache *btrfs_inode_cachep;
struct kmem_cache *btrfs_trans_handle_cachep;
struct kmem_cache *btrfs_transaction_cachep;
struct kmem_cache *btrfs_bit_radix_cachep;
struct kmem_cache *btrfs_path_cachep;

#define S_SHIFT 12
static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
	[S_IFREG >> S_SHIFT]	= BTRFS_FT_REG_FILE,
	[S_IFDIR >> S_SHIFT]	= BTRFS_FT_DIR,
	[S_IFCHR >> S_SHIFT]	= BTRFS_FT_CHRDEV,
	[S_IFBLK >> S_SHIFT]	= BTRFS_FT_BLKDEV,
	[S_IFIFO >> S_SHIFT]	= BTRFS_FT_FIFO,
	[S_IFSOCK >> S_SHIFT]	= BTRFS_FT_SOCK,
	[S_IFLNK >> S_SHIFT]	= BTRFS_FT_SYMLINK,
};

75 76 77 78 79 80 81 82 83
int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
			   int for_del)
{
	u64 total = btrfs_super_total_bytes(&root->fs_info->super_copy);
	u64 used = btrfs_super_bytes_used(&root->fs_info->super_copy);
	u64 thresh;
	int ret = 0;

	if (for_del)
84
		thresh = total * 90;
85
	else
86 87 88
		thresh = total * 85;

	do_div(thresh, 100);
89 90 91 92 93 94 95 96

	spin_lock(&root->fs_info->delalloc_lock);
	if (used + root->fs_info->delalloc_bytes + num_required > thresh)
		ret = -ENOSPC;
	spin_unlock(&root->fs_info->delalloc_lock);
	return ret;
}

97
static int cow_file_range(struct inode *inode, u64 start, u64 end)
98 99 100 101
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	u64 alloc_hint = 0;
102
	u64 num_bytes;
103
	u64 cur_alloc_size;
104
	u64 blocksize = root->sectorsize;
105 106
	struct btrfs_key ins;
	int ret;
107 108 109

	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);
110 111
	btrfs_set_trans_block_group(trans, inode);

112
	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
113
	num_bytes = max(blocksize,  num_bytes);
114
	ret = btrfs_drop_extents(trans, root, inode,
115
				 start, start + num_bytes, start, &alloc_hint);
116

117 118 119
	if (alloc_hint == EXTENT_MAP_INLINE)
		goto out;

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	while(num_bytes > 0) {
		cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
		ret = btrfs_alloc_extent(trans, root, cur_alloc_size,
					 root->root_key.objectid,
					 trans->transid,
					 inode->i_ino, start, 0,
					 alloc_hint, (u64)-1, &ins, 1);
		if (ret) {
			WARN_ON(1);
			goto out;
		}
		ret = btrfs_insert_file_extent(trans, root, inode->i_ino,
					       start, ins.objectid, ins.offset,
					       ins.offset);
		num_bytes -= cur_alloc_size;
		alloc_hint = ins.objectid + ins.offset;
		start += cur_alloc_size;
137 138 139
	}
out:
	btrfs_end_transaction(trans, root);
140 141 142 143 144 145 146 147 148
	return ret;
}

static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
{
	u64 extent_start;
	u64 extent_end;
	u64 bytenr;
	u64 cow_end;
149
	u64 loops = 0;
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_buffer *leaf;
	int found_type;
	struct btrfs_path *path;
	struct btrfs_file_extent_item *item;
	int ret;
	int err;
	struct btrfs_key found_key;

	path = btrfs_alloc_path();
	BUG_ON(!path);
again:
	ret = btrfs_lookup_file_extent(NULL, root, path,
				       inode->i_ino, start, 0);
	if (ret < 0) {
		btrfs_free_path(path);
		return ret;
	}

	cow_end = end;
	if (ret != 0) {
		if (path->slots[0] == 0)
			goto not_found;
		path->slots[0]--;
	}

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

	/* are we inside the extent that was found? */
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != inode->i_ino ||
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
	if (found_type == BTRFS_FILE_EXTENT_REG) {
		extent_end = extent_start +
		       btrfs_file_extent_num_bytes(leaf, item);
		err = 0;

195 196 197
		if (loops && start != extent_start)
			goto not_found;

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
		if (start < extent_start || start >= extent_end)
			goto not_found;

		cow_end = min(end, extent_end - 1);
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0)
			goto not_found;

		if (btrfs_count_snapshots_in_path(root, path, bytenr) != 1) {
			goto not_found;
		}

		start = extent_end;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
		goto not_found;
	}
loop:
	if (start > end) {
		btrfs_free_path(path);
		return 0;
	}
	btrfs_release_path(root, path);
220
	loops++;
221 222 223 224 225 226 227 228 229 230 231
	goto again;

not_found:
	cow_file_range(inode, start, cow_end);
	start = cow_end + 1;
	goto loop;
}

static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
232
	u64 num_bytes;
233 234 235 236 237 238 239
	int ret;

	mutex_lock(&root->fs_info->fs_mutex);
	if (btrfs_test_opt(root, NODATACOW))
		ret = run_delalloc_nocow(inode, start, end);
	else
		ret = cow_file_range(inode, start, end);
240 241 242 243 244 245 246 247 248 249 250

	spin_lock(&root->fs_info->delalloc_lock);
	num_bytes = end + 1 - start;
	if (root->fs_info->delalloc_bytes < num_bytes) {
		printk("delalloc accounting error total %llu sub %llu\n",
		       root->fs_info->delalloc_bytes, num_bytes);
	} else {
		root->fs_info->delalloc_bytes -= num_bytes;
	}
	spin_unlock(&root->fs_info->delalloc_lock);

251 252 253 254
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

255 256 257 258 259 260
int btrfs_writepage_io_hook(struct page *page, u64 start, u64 end)
{
	struct inode *inode = page->mapping->host;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	char *kaddr;
261
	int ret = 0;
262
	u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
263 264
	size_t offset = start - page_start;

265 266 267
	if (btrfs_test_opt(root, NODATASUM))
		return 0;

268 269 270 271
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
	kaddr = kmap(page);
272
	btrfs_csum_file_block(trans, root, inode, inode->i_ino,
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
			      start, kaddr + offset, end - start + 1);
	kunmap(page);
	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
{
	int ret = 0;
	struct inode *inode = page->mapping->host;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct btrfs_csum_item *item;
	struct btrfs_path *path = NULL;
289
	u32 csum;
290

291 292 293
	if (btrfs_test_opt(root, NODATASUM))
		return 0;

294 295 296 297 298 299 300 301
	mutex_lock(&root->fs_info->fs_mutex);
	path = btrfs_alloc_path();
	item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
	if (IS_ERR(item)) {
		ret = PTR_ERR(item);
		/* a csum that isn't present is a preallocated region. */
		if (ret == -ENOENT || ret == -EFBIG)
			ret = 0;
302
		csum = 0;
303 304
		goto out;
	}
305 306 307
	read_extent_buffer(path->nodes[0], &csum, (unsigned long)item,
			   BTRFS_CRC32_SIZE);
	set_state_private(em_tree, start, csum);
308 309 310 311 312 313 314 315 316
out:
	if (path)
		btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end)
{
317
	size_t offset = start - ((u64)page->index << PAGE_CACHE_SHIFT);
318 319 320 321 322
	struct inode *inode = page->mapping->host;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	char *kaddr;
	u64 private;
	int ret;
323 324
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 csum = ~(u32)0;
325
	unsigned long flags;
326

327 328 329
	if (btrfs_test_opt(root, NODATASUM))
		return 0;

330
	ret = get_state_private(em_tree, start, &private);
331
	local_irq_save(flags);
332 333 334 335
	kaddr = kmap_atomic(page, KM_IRQ0);
	if (ret) {
		goto zeroit;
	}
336 337 338
	csum = btrfs_csum_data(root, kaddr + offset, csum,  end - start + 1);
	btrfs_csum_final(csum, (char *)&csum);
	if (csum != private) {
339 340 341
		goto zeroit;
	}
	kunmap_atomic(kaddr, KM_IRQ0);
342
	local_irq_restore(flags);
343 344 345 346 347
	return 0;

zeroit:
	printk("btrfs csum failed ino %lu off %llu\n",
	       page->mapping->host->i_ino, (unsigned long long)start);
348 349
	memset(kaddr + offset, 1, end - start + 1);
	flush_dcache_page(page);
350
	kunmap_atomic(kaddr, KM_IRQ0);
351
	local_irq_restore(flags);
352 353
	return 0;
}
354

C
Chris Mason 已提交
355 356 357
void btrfs_read_locked_inode(struct inode *inode)
{
	struct btrfs_path *path;
358
	struct extent_buffer *leaf;
C
Chris Mason 已提交
359
	struct btrfs_inode_item *inode_item;
360
	struct btrfs_inode_timespec *tspec;
C
Chris Mason 已提交
361 362 363
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_key location;
	u64 alloc_group_block;
J
Josef Bacik 已提交
364
	u32 rdev;
C
Chris Mason 已提交
365 366 367 368 369 370 371 372
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	mutex_lock(&root->fs_info->fs_mutex);

	memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
	ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
373
	if (ret)
C
Chris Mason 已提交
374 375
		goto make_bad;

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
				    struct btrfs_inode_item);

	inode->i_mode = btrfs_inode_mode(leaf, inode_item);
	inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
	inode->i_uid = btrfs_inode_uid(leaf, inode_item);
	inode->i_gid = btrfs_inode_gid(leaf, inode_item);
	inode->i_size = btrfs_inode_size(leaf, inode_item);

	tspec = btrfs_inode_atime(inode_item);
	inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

	tspec = btrfs_inode_mtime(inode_item);
	inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

	tspec = btrfs_inode_ctime(inode_item);
	inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
	inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);

	inode->i_blocks = btrfs_inode_nblocks(leaf, inode_item);
	inode->i_generation = btrfs_inode_generation(leaf, inode_item);
J
Josef Bacik 已提交
400
	inode->i_rdev = 0;
401 402 403
	rdev = btrfs_inode_rdev(leaf, inode_item);

	alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
C
Chris Mason 已提交
404 405 406
	BTRFS_I(inode)->block_group = btrfs_lookup_block_group(root->fs_info,
						       alloc_group_block);

407 408 409 410
	if (!BTRFS_I(inode)->block_group) {
		BTRFS_I(inode)->block_group = btrfs_find_block_group(root,
						         NULL, 0, 0, 0);
	}
C
Chris Mason 已提交
411 412 413 414 415 416 417 418
	btrfs_free_path(path);
	inode_item = NULL;

	mutex_unlock(&root->fs_info->fs_mutex);

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &btrfs_aops;
419
		BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
C
Chris Mason 已提交
420 421 422 423 424 425 426 427 428 429 430 431 432 433
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
		break;
	case S_IFDIR:
		inode->i_fop = &btrfs_dir_file_operations;
		if (root == root->fs_info->tree_root)
			inode->i_op = &btrfs_dir_ro_inode_operations;
		else
			inode->i_op = &btrfs_dir_inode_operations;
		break;
	case S_IFLNK:
		inode->i_op = &btrfs_symlink_inode_operations;
		inode->i_mapping->a_ops = &btrfs_symlink_aops;
		break;
J
Josef Bacik 已提交
434 435 436
	default:
		init_special_inode(inode, inode->i_mode, rdev);
		break;
C
Chris Mason 已提交
437 438 439 440 441 442 443 444 445 446
	}
	return;

make_bad:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
	make_bad_inode(inode);
}

447 448
static void fill_inode_item(struct extent_buffer *leaf,
			    struct btrfs_inode_item *item,
C
Chris Mason 已提交
449 450
			    struct inode *inode)
{
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	btrfs_set_inode_uid(leaf, item, inode->i_uid);
	btrfs_set_inode_gid(leaf, item, inode->i_gid);
	btrfs_set_inode_size(leaf, item, inode->i_size);
	btrfs_set_inode_mode(leaf, item, inode->i_mode);
	btrfs_set_inode_nlink(leaf, item, inode->i_nlink);

	btrfs_set_timespec_sec(leaf, btrfs_inode_atime(item),
			       inode->i_atime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_atime(item),
				inode->i_atime.tv_nsec);

	btrfs_set_timespec_sec(leaf, btrfs_inode_mtime(item),
			       inode->i_mtime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_mtime(item),
				inode->i_mtime.tv_nsec);

	btrfs_set_timespec_sec(leaf, btrfs_inode_ctime(item),
			       inode->i_ctime.tv_sec);
	btrfs_set_timespec_nsec(leaf, btrfs_inode_ctime(item),
				inode->i_ctime.tv_nsec);

	btrfs_set_inode_nblocks(leaf, item, inode->i_blocks);
	btrfs_set_inode_generation(leaf, item, inode->i_generation);
	btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
	btrfs_set_inode_block_group(leaf, item,
C
Chris Mason 已提交
476 477 478
				    BTRFS_I(inode)->block_group->key.objectid);
}

479
int btrfs_update_inode(struct btrfs_trans_handle *trans,
C
Chris Mason 已提交
480 481 482 483 484
			      struct btrfs_root *root,
			      struct inode *inode)
{
	struct btrfs_inode_item *inode_item;
	struct btrfs_path *path;
485
	struct extent_buffer *leaf;
C
Chris Mason 已提交
486 487 488 489 490 491 492 493 494 495 496 497
	int ret;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, 1);
	if (ret) {
		if (ret > 0)
			ret = -ENOENT;
		goto failed;
	}

498 499
	leaf = path->nodes[0];
	inode_item = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
500 501
				  struct btrfs_inode_item);

502 503
	fill_inode_item(leaf, inode_item, inode);
	btrfs_mark_buffer_dirty(leaf);
504
	btrfs_set_inode_last_trans(trans, inode);
C
Chris Mason 已提交
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
	ret = 0;
failed:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	return ret;
}


static int btrfs_unlink_trans(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct inode *dir,
			      struct dentry *dentry)
{
	struct btrfs_path *path;
	const char *name = dentry->d_name.name;
	int name_len = dentry->d_name.len;
	int ret = 0;
522
	struct extent_buffer *leaf;
C
Chris Mason 已提交
523
	struct btrfs_dir_item *di;
524
	struct btrfs_key key;
C
Chris Mason 已提交
525 526

	path = btrfs_alloc_path();
527 528 529 530 531
	if (!path) {
		ret = -ENOMEM;
		goto err;
	}

C
Chris Mason 已提交
532 533 534 535 536 537 538 539 540 541
	di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
				    name, name_len, -1);
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
542 543
	leaf = path->nodes[0];
	btrfs_dir_item_key_to_cpu(leaf, di, &key);
C
Chris Mason 已提交
544
	ret = btrfs_delete_one_dir_name(trans, root, path, di);
545 546
	if (ret)
		goto err;
C
Chris Mason 已提交
547 548 549
	btrfs_release_path(root, path);

	di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
550
					 key.objectid, name, name_len, -1);
C
Chris Mason 已提交
551 552 553 554 555 556 557 558 559 560 561
	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto err;
	}
	if (!di) {
		ret = -ENOENT;
		goto err;
	}
	ret = btrfs_delete_one_dir_name(trans, root, path, di);

	dentry->d_inode->i_ctime = dir->i_ctime;
562 563 564 565 566 567 568 569
	ret = btrfs_del_inode_ref(trans, root, name, name_len,
				  dentry->d_inode->i_ino,
				  dentry->d_parent->d_inode->i_ino);
	if (ret) {
		printk("failed to delete reference to %.*s, "
		       "inode %lu parent %lu\n", name_len, name,
		       dentry->d_inode->i_ino,
		       dentry->d_parent->d_inode->i_ino);
570
	}
C
Chris Mason 已提交
571 572 573 574
err:
	btrfs_free_path(path);
	if (!ret) {
		dir->i_size -= name_len * 2;
575
		dir->i_mtime = dir->i_ctime = CURRENT_TIME;
C
Chris Mason 已提交
576
		btrfs_update_inode(trans, root, dir);
577 578 579
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
		dentry->d_inode->i_nlink--;
#else
C
Chris Mason 已提交
580
		drop_nlink(dentry->d_inode);
581
#endif
582
		ret = btrfs_update_inode(trans, root, dentry->d_inode);
C
Chris Mason 已提交
583 584 585 586 587 588 589 590 591 592
		dir->i_sb->s_dirt = 1;
	}
	return ret;
}

static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
{
	struct btrfs_root *root;
	struct btrfs_trans_handle *trans;
	int ret;
593
	unsigned long nr = 0;
C
Chris Mason 已提交
594 595 596

	root = BTRFS_I(dir)->root;
	mutex_lock(&root->fs_info->fs_mutex);
597 598 599 600 601

	ret = btrfs_check_free_space(root, 1, 1);
	if (ret)
		goto fail;

C
Chris Mason 已提交
602
	trans = btrfs_start_transaction(root, 1);
603

C
Chris Mason 已提交
604 605
	btrfs_set_trans_block_group(trans, dir);
	ret = btrfs_unlink_trans(trans, root, dir, dentry);
606
	nr = trans->blocks_used;
607

C
Chris Mason 已提交
608
	btrfs_end_transaction(trans, root);
609
fail:
C
Chris Mason 已提交
610
	mutex_unlock(&root->fs_info->fs_mutex);
611
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
612 613 614 615 616 617
	return ret;
}

static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
618
	int err = 0;
C
Chris Mason 已提交
619 620 621
	int ret;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_trans_handle *trans;
622
	unsigned long nr = 0;
C
Chris Mason 已提交
623

Y
Yan 已提交
624 625 626
	if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
		return -ENOTEMPTY;

C
Chris Mason 已提交
627
	mutex_lock(&root->fs_info->fs_mutex);
628 629 630 631
	ret = btrfs_check_free_space(root, 1, 1);
	if (ret)
		goto fail;

C
Chris Mason 已提交
632 633 634 635 636 637 638 639
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	/* now the directory is empty */
	err = btrfs_unlink_trans(trans, root, dir, dentry);
	if (!err) {
		inode->i_size = 0;
	}
640

641
	nr = trans->blocks_used;
C
Chris Mason 已提交
642
	ret = btrfs_end_transaction(trans, root);
643
fail:
Y
Yan 已提交
644
	mutex_unlock(&root->fs_info->fs_mutex);
645
	btrfs_btree_balance_dirty(root, nr);
646

C
Chris Mason 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
	if (ret && !err)
		err = ret;
	return err;
}

static int btrfs_free_inode(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct inode *inode)
{
	struct btrfs_path *path;
	int ret;

	clear_inode(inode);

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_lookup_inode(trans, root, path,
				 &BTRFS_I(inode)->location, -1);
665 666 667 668
	if (ret > 0)
		ret = -ENOENT;
	if (!ret)
		ret = btrfs_del_item(trans, root, path);
C
Chris Mason 已提交
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
	btrfs_free_path(path);
	return ret;
}

/*
 * this can truncate away extent items, csum items and directory items.
 * It starts at a high offset and removes keys until it can't find
 * any higher than i_size.
 *
 * csum items that cross the new i_size are truncated to the new size
 * as well.
 */
static int btrfs_truncate_in_trans(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct inode *inode)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;
688
	struct btrfs_key found_key;
C
Chris Mason 已提交
689
	u32 found_type;
690
	struct extent_buffer *leaf;
C
Chris Mason 已提交
691 692
	struct btrfs_file_extent_item *fi;
	u64 extent_start = 0;
693
	u64 extent_num_bytes = 0;
C
Chris Mason 已提交
694
	u64 item_end = 0;
695
	u64 root_gen = 0;
696
	u64 root_owner = 0;
C
Chris Mason 已提交
697 698
	int found_extent;
	int del_item;
699
	int extent_type = -1;
C
Chris Mason 已提交
700

701
	btrfs_drop_extent_cache(inode, inode->i_size, (u64)-1);
C
Chris Mason 已提交
702
	path = btrfs_alloc_path();
703
	path->reada = -1;
C
Chris Mason 已提交
704
	BUG_ON(!path);
705

C
Chris Mason 已提交
706 707 708
	/* FIXME, add redo link to tree so we don't leak on crash */
	key.objectid = inode->i_ino;
	key.offset = (u64)-1;
709 710
	key.type = (u8)-1;

C
Chris Mason 已提交
711 712 713 714 715 716 717 718 719 720 721
	while(1) {
		btrfs_init_path(path);
		fi = NULL;
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret < 0) {
			goto error;
		}
		if (ret > 0) {
			BUG_ON(path->slots[0] == 0);
			path->slots[0]--;
		}
722 723 724
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		found_type = btrfs_key_type(&found_key);
C
Chris Mason 已提交
725

726
		if (found_key.objectid != inode->i_ino)
C
Chris Mason 已提交
727
			break;
728

C
Chris Mason 已提交
729 730 731 732 733 734
		if (found_type != BTRFS_CSUM_ITEM_KEY &&
		    found_type != BTRFS_DIR_ITEM_KEY &&
		    found_type != BTRFS_DIR_INDEX_KEY &&
		    found_type != BTRFS_EXTENT_DATA_KEY)
			break;

735
		item_end = found_key.offset;
C
Chris Mason 已提交
736
		if (found_type == BTRFS_EXTENT_DATA_KEY) {
737
			fi = btrfs_item_ptr(leaf, path->slots[0],
C
Chris Mason 已提交
738
					    struct btrfs_file_extent_item);
739 740
			extent_type = btrfs_file_extent_type(leaf, fi);
			if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
741
				item_end +=
742
				    btrfs_file_extent_num_bytes(leaf, fi);
743 744 745 746 747
			} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
				struct btrfs_item *item = btrfs_item_nr(leaf,
							        path->slots[0]);
				item_end += btrfs_file_extent_inline_len(leaf,
									 item);
C
Chris Mason 已提交
748
			}
749
			item_end--;
C
Chris Mason 已提交
750 751 752 753 754 755
		}
		if (found_type == BTRFS_CSUM_ITEM_KEY) {
			ret = btrfs_csum_truncate(trans, root, path,
						  inode->i_size);
			BUG_ON(ret);
		}
756
		if (item_end < inode->i_size) {
757 758 759 760 761 762 763 764
			if (found_type == BTRFS_DIR_ITEM_KEY) {
				found_type = BTRFS_INODE_ITEM_KEY;
			} else if (found_type == BTRFS_EXTENT_ITEM_KEY) {
				found_type = BTRFS_CSUM_ITEM_KEY;
			} else if (found_type) {
				found_type--;
			} else {
				break;
C
Chris Mason 已提交
765
			}
766
			btrfs_set_key_type(&key, found_type);
Y
Yan 已提交
767
			btrfs_release_path(root, path);
768
			continue;
C
Chris Mason 已提交
769
		}
770
		if (found_key.offset >= inode->i_size)
C
Chris Mason 已提交
771 772 773 774 775 776
			del_item = 1;
		else
			del_item = 0;
		found_extent = 0;

		/* FIXME, shrink the extent if the ref count is only 1 */
777 778 779 780
		if (found_type != BTRFS_EXTENT_DATA_KEY)
			goto delete;

		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
C
Chris Mason 已提交
781
			u64 num_dec;
782
			extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
C
Chris Mason 已提交
783
			if (!del_item) {
784 785 786
				u64 orig_num_bytes =
					btrfs_file_extent_num_bytes(leaf, fi);
				extent_num_bytes = inode->i_size -
787
					found_key.offset + root->sectorsize - 1;
788 789 790 791
				btrfs_set_file_extent_num_bytes(leaf, fi,
							 extent_num_bytes);
				num_dec = (orig_num_bytes -
					   extent_num_bytes) >> 9;
792 793 794
				if (extent_start != 0) {
					inode->i_blocks -= num_dec;
				}
795
				btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
796
			} else {
797 798 799
				extent_num_bytes =
					btrfs_file_extent_disk_num_bytes(leaf,
									 fi);
C
Chris Mason 已提交
800
				/* FIXME blocksize != 4096 */
801 802
				num_dec = btrfs_file_extent_num_bytes(leaf,
								       fi) >> 9;
C
Chris Mason 已提交
803 804 805 806
				if (extent_start != 0) {
					found_extent = 1;
					inode->i_blocks -= num_dec;
				}
807 808
				root_gen = btrfs_header_generation(leaf);
				root_owner = btrfs_header_owner(leaf);
C
Chris Mason 已提交
809
			}
810 811 812 813 814 815 816
		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE &&
			   !del_item) {
			u32 newsize = inode->i_size - found_key.offset;
			newsize = btrfs_file_extent_calc_inline_size(newsize);
			ret = btrfs_truncate_item(trans, root, path,
						  newsize, 1);
			BUG_ON(ret);
C
Chris Mason 已提交
817
		}
818
delete:
C
Chris Mason 已提交
819 820
		if (del_item) {
			ret = btrfs_del_item(trans, root, path);
821 822
			if (ret)
				goto error;
C
Chris Mason 已提交
823 824 825 826 827 828
		} else {
			break;
		}
		btrfs_release_path(root, path);
		if (found_extent) {
			ret = btrfs_free_extent(trans, root, extent_start,
829
						extent_num_bytes,
830
						root_owner,
831 832
						root_gen, inode->i_ino,
						found_key.offset, 0);
C
Chris Mason 已提交
833 834 835 836 837 838 839 840 841 842 843
			BUG_ON(ret);
		}
	}
	ret = 0;
error:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	inode->i_sb->s_dirt = 1;
	return ret;
}

844
static int btrfs_cow_one_page(struct inode *inode, struct page *page,
845 846 847
			      size_t zero_start)
{
	char *kaddr;
848
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
849
	struct btrfs_root *root = BTRFS_I(inode)->root;
850
	u64 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
851
	u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
852 853 854
	u64 existing_delalloc;
	u64 delalloc_start;
	int ret = 0;
855

856
	WARN_ON(!PageLocked(page));
857
	set_page_extent_mapped(page);
858

859
	lock_extent(em_tree, page_start, page_end, GFP_NOFS);
860 861 862 863
	delalloc_start = page_start;
	existing_delalloc = count_range_bits(&BTRFS_I(inode)->extent_tree,
					     &delalloc_start, page_end,
					     PAGE_CACHE_SIZE, EXTENT_DELALLOC);
864 865
	set_extent_delalloc(&BTRFS_I(inode)->extent_tree, page_start,
			    page_end, GFP_NOFS);
866 867 868 869 870

	spin_lock(&root->fs_info->delalloc_lock);
	root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE - existing_delalloc;
	spin_unlock(&root->fs_info->delalloc_lock);

871
	if (zero_start != PAGE_CACHE_SIZE) {
872
		kaddr = kmap(page);
873 874
		memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
		flush_dcache_page(page);
875
		kunmap(page);
876
	}
877 878
	set_page_dirty(page);
	unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
879 880 881 882

	return ret;
}

C
Chris Mason 已提交
883 884 885 886 887 888 889
/*
 * taken from block_truncate_page, but does cow as it zeros out
 * any bytes left in the last page in the file.
 */
static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
{
	struct inode *inode = mapping->host;
890 891
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u32 blocksize = root->sectorsize;
C
Chris Mason 已提交
892 893 894 895
	pgoff_t index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	struct page *page;
	int ret = 0;
896
	u64 page_start;
C
Chris Mason 已提交
897 898 899 900

	if ((offset & (blocksize - 1)) == 0)
		goto out;

901
	down_read(&root->snap_sem);
C
Chris Mason 已提交
902 903 904 905 906
	ret = -ENOMEM;
	page = grab_cache_page(mapping, index);
	if (!page)
		goto out;
	if (!PageUptodate(page)) {
C
Chris Mason 已提交
907
		ret = btrfs_readpage(NULL, page);
C
Chris Mason 已提交
908 909 910 911 912 913
		lock_page(page);
		if (!PageUptodate(page)) {
			ret = -EIO;
			goto out;
		}
	}
914
	page_start = (u64)page->index << PAGE_CACHE_SHIFT;
915

916
	ret = btrfs_cow_one_page(inode, page, offset);
C
Chris Mason 已提交
917 918 919

	unlock_page(page);
	page_cache_release(page);
920
	up_read(&BTRFS_I(inode)->root->snap_sem);
C
Chris Mason 已提交
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
out:
	return ret;
}

static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int err;

	err = inode_change_ok(inode, attr);
	if (err)
		return err;

	if (S_ISREG(inode->i_mode) &&
	    attr->ia_valid & ATTR_SIZE && attr->ia_size > inode->i_size) {
		struct btrfs_trans_handle *trans;
		struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
938 939
		struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;

940
		u64 mask = root->sectorsize - 1;
C
Chris Mason 已提交
941
		u64 pos = (inode->i_size + mask) & ~mask;
C
Chris Mason 已提交
942
		u64 block_end = attr->ia_size | mask;
C
Chris Mason 已提交
943
		u64 hole_size;
944
		u64 alloc_hint = 0;
C
Chris Mason 已提交
945 946 947 948

		if (attr->ia_size <= pos)
			goto out;

949 950 951 952 953 954
		mutex_lock(&root->fs_info->fs_mutex);
		err = btrfs_check_free_space(root, 1, 0);
		mutex_unlock(&root->fs_info->fs_mutex);
		if (err)
			goto fail;

C
Chris Mason 已提交
955 956
		btrfs_truncate_page(inode->i_mapping, inode->i_size);

C
Chris Mason 已提交
957
		lock_extent(em_tree, pos, block_end, GFP_NOFS);
C
Chris Mason 已提交
958 959 960 961 962
		hole_size = (attr->ia_size - pos + mask) & ~mask;

		mutex_lock(&root->fs_info->fs_mutex);
		trans = btrfs_start_transaction(root, 1);
		btrfs_set_trans_block_group(trans, inode);
C
Chris Mason 已提交
963
		err = btrfs_drop_extents(trans, root, inode,
964 965
					 pos, pos + hole_size, pos,
					 &alloc_hint);
C
Chris Mason 已提交
966

967 968 969 970 971
		if (alloc_hint != EXTENT_MAP_INLINE) {
			err = btrfs_insert_file_extent(trans, root,
						       inode->i_ino,
						       pos, 0, 0, hole_size);
		}
C
Chris Mason 已提交
972 973
		btrfs_end_transaction(trans, root);
		mutex_unlock(&root->fs_info->fs_mutex);
C
Chris Mason 已提交
974
		unlock_extent(em_tree, pos, block_end, GFP_NOFS);
975 976
		if (err)
			return err;
C
Chris Mason 已提交
977 978 979
	}
out:
	err = inode_setattr(inode, attr);
980
fail:
C
Chris Mason 已提交
981 982 983 984 985 986
	return err;
}
void btrfs_delete_inode(struct inode *inode)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(inode)->root;
987
	unsigned long nr;
C
Chris Mason 已提交
988 989 990 991 992 993
	int ret;

	truncate_inode_pages(&inode->i_data, 0);
	if (is_bad_inode(inode)) {
		goto no_delete;
	}
994

C
Chris Mason 已提交
995 996 997
	inode->i_size = 0;
	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
998

C
Chris Mason 已提交
999 1000
	btrfs_set_trans_block_group(trans, inode);
	ret = btrfs_truncate_in_trans(trans, root, inode);
J
Josef Bacik 已提交
1001 1002 1003
	if (ret)
		goto no_delete_lock;
	ret = btrfs_delete_xattrs(trans, root, inode);
1004 1005 1006 1007 1008
	if (ret)
		goto no_delete_lock;
	ret = btrfs_free_inode(trans, root, inode);
	if (ret)
		goto no_delete_lock;
1009
	nr = trans->blocks_used;
1010

C
Chris Mason 已提交
1011 1012
	btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
1013
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
1014
	return;
1015 1016

no_delete_lock:
1017
	nr = trans->blocks_used;
1018 1019
	btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
1020
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
no_delete:
	clear_inode(inode);
}

/*
 * this returns the key found in the dir entry in the location pointer.
 * If no dir entries were found, location->objectid is 0.
 */
static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
			       struct btrfs_key *location)
{
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	struct btrfs_root *root = BTRFS_I(dir)->root;
Y
Yan 已提交
1037
	int ret = 0;
C
Chris Mason 已提交
1038

1039 1040 1041 1042 1043 1044
	if (namelen == 1 && strcmp(name, ".") == 0) {
		location->objectid = dir->i_ino;
		location->type = BTRFS_INODE_ITEM_KEY;
		location->offset = 0;
		return 0;
	}
C
Chris Mason 已提交
1045 1046
	path = btrfs_alloc_path();
	BUG_ON(!path);
1047

1048
	if (namelen == 2 && strcmp(name, "..") == 0) {
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
		struct btrfs_key key;
		struct extent_buffer *leaf;
		u32 nritems;
		int slot;

		key.objectid = dir->i_ino;
		btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
		key.offset = 0;
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		BUG_ON(ret == 0);
		ret = 0;

		leaf = path->nodes[0];
		slot = path->slots[0];
		nritems = btrfs_header_nritems(leaf);
		if (slot >= nritems)
			goto out_err;

		btrfs_item_key_to_cpu(leaf, &key, slot);
		if (key.objectid != dir->i_ino ||
		    key.type != BTRFS_INODE_REF_KEY) {
			goto out_err;
		}
		location->objectid = key.offset;
		location->type = BTRFS_INODE_ITEM_KEY;
		location->offset = 0;
		goto out;
	}

C
Chris Mason 已提交
1078 1079
	di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
				    namelen, 0);
Y
Yan 已提交
1080 1081
	if (IS_ERR(di))
		ret = PTR_ERR(di);
C
Chris Mason 已提交
1082
	if (!di || IS_ERR(di)) {
1083
		goto out_err;
C
Chris Mason 已提交
1084
	}
1085
	btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
C
Chris Mason 已提交
1086 1087 1088
out:
	btrfs_free_path(path);
	return ret;
1089 1090 1091
out_err:
	location->objectid = 0;
	goto out;
C
Chris Mason 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100
}

/*
 * when we hit a tree root in a directory, the btrfs part of the inode
 * needs to be changed to reflect the root directory of the tree root.  This
 * is kind of like crossing a mount point.
 */
static int fixup_tree_root_location(struct btrfs_root *root,
			     struct btrfs_key *location,
1101 1102
			     struct btrfs_root **sub_root,
			     struct dentry *dentry)
C
Chris Mason 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
{
	struct btrfs_path *path;
	struct btrfs_root_item *ri;

	if (btrfs_key_type(location) != BTRFS_ROOT_ITEM_KEY)
		return 0;
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return 0;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	mutex_lock(&root->fs_info->fs_mutex);

1116 1117 1118
	*sub_root = btrfs_read_fs_root(root->fs_info, location,
					dentry->d_name.name,
					dentry->d_name.len);
C
Chris Mason 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
	if (IS_ERR(*sub_root))
		return PTR_ERR(*sub_root);

	ri = &(*sub_root)->root_item;
	location->objectid = btrfs_root_dirid(ri);
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
	location->offset = 0;

	btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
	return 0;
}

static int btrfs_init_locked_inode(struct inode *inode, void *p)
{
	struct btrfs_iget_args *args = p;
	inode->i_ino = args->ino;
	BTRFS_I(inode)->root = args->root;
1137 1138
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
			     inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
	return 0;
}

static int btrfs_find_actor(struct inode *inode, void *opaque)
{
	struct btrfs_iget_args *args = opaque;
	return (args->ino == inode->i_ino &&
		args->root == BTRFS_I(inode)->root);
}

struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
				struct btrfs_root *root)
{
	struct inode *inode;
	struct btrfs_iget_args args;
	args.ino = objectid;
	args.root = root;

	inode = iget5_locked(s, objectid, btrfs_find_actor,
			     btrfs_init_locked_inode,
			     (void *)&args);
	return inode;
}

static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
				   struct nameidata *nd)
{
	struct inode * inode;
	struct btrfs_inode *bi = BTRFS_I(dir);
	struct btrfs_root *root = bi->root;
	struct btrfs_root *sub_root = root;
	struct btrfs_key location;
	int ret;

	if (dentry->d_name.len > BTRFS_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);
1175

C
Chris Mason 已提交
1176 1177 1178
	mutex_lock(&root->fs_info->fs_mutex);
	ret = btrfs_inode_by_name(dir, dentry, &location);
	mutex_unlock(&root->fs_info->fs_mutex);
1179

C
Chris Mason 已提交
1180 1181
	if (ret < 0)
		return ERR_PTR(ret);
1182

C
Chris Mason 已提交
1183 1184
	inode = NULL;
	if (location.objectid) {
1185 1186
		ret = fixup_tree_root_location(root, &location, &sub_root,
						dentry);
C
Chris Mason 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
		if (ret < 0)
			return ERR_PTR(ret);
		if (ret > 0)
			return ERR_PTR(-ENOENT);
		inode = btrfs_iget_locked(dir->i_sb, location.objectid,
					  sub_root);
		if (!inode)
			return ERR_PTR(-EACCES);
		if (inode->i_state & I_NEW) {
			/* the inode and parent dir are two different roots */
			if (sub_root != root) {
				igrab(inode);
				sub_root->inode = inode;
			}
			BTRFS_I(inode)->root = sub_root;
			memcpy(&BTRFS_I(inode)->location, &location,
			       sizeof(location));
			btrfs_read_locked_inode(inode);
			unlock_new_inode(inode);
		}
	}
	return d_splice_alias(inode, dentry);
}

static unsigned char btrfs_filetype_table[] = {
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
};

static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
1217
	struct inode *inode = filp->f_dentry->d_inode;
C
Chris Mason 已提交
1218 1219 1220 1221
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_item *item;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
1222
	struct btrfs_key found_key;
C
Chris Mason 已提交
1223 1224 1225
	struct btrfs_path *path;
	int ret;
	u32 nritems;
1226
	struct extent_buffer *leaf;
C
Chris Mason 已提交
1227 1228 1229 1230 1231 1232 1233 1234
	int slot;
	int advance;
	unsigned char d_type;
	int over = 0;
	u32 di_cur;
	u32 di_total;
	u32 di_len;
	int key_type = BTRFS_DIR_INDEX_KEY;
1235 1236 1237
	char tmp_name[32];
	char *name_ptr;
	int name_len;
C
Chris Mason 已提交
1238 1239 1240 1241

	/* FIXME, use a real flag for deciding about the key type */
	if (root->fs_info->tree_root == root)
		key_type = BTRFS_DIR_ITEM_KEY;
1242

1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
	/* special case for "." */
	if (filp->f_pos == 0) {
		over = filldir(dirent, ".", 1,
			       1, inode->i_ino,
			       DT_DIR);
		if (over)
			return 0;
		filp->f_pos = 1;
	}

C
Chris Mason 已提交
1253 1254
	mutex_lock(&root->fs_info->fs_mutex);
	key.objectid = inode->i_ino;
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
	path = btrfs_alloc_path();
	path->reada = 2;

	/* special case for .., just use the back ref */
	if (filp->f_pos == 1) {
		btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY);
		key.offset = 0;
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		BUG_ON(ret == 0);
		leaf = path->nodes[0];
		slot = path->slots[0];
		nritems = btrfs_header_nritems(leaf);
		if (slot >= nritems) {
			btrfs_release_path(root, path);
			goto read_dir_items;
		}
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
		btrfs_release_path(root, path);
		if (found_key.objectid != key.objectid ||
		    found_key.type != BTRFS_INODE_REF_KEY)
			goto read_dir_items;
		over = filldir(dirent, "..", 2,
			       2, found_key.offset, DT_DIR);
		if (over)
			goto nopos;
		filp->f_pos = 2;
	}

read_dir_items:
C
Chris Mason 已提交
1284 1285
	btrfs_set_key_type(&key, key_type);
	key.offset = filp->f_pos;
1286

C
Chris Mason 已提交
1287 1288 1289 1290 1291
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto err;
	advance = 0;
	while(1) {
1292 1293
		leaf = path->nodes[0];
		nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
1294 1295 1296 1297 1298 1299
		slot = path->slots[0];
		if (advance || slot >= nritems) {
			if (slot >= nritems -1) {
				ret = btrfs_next_leaf(root, path);
				if (ret)
					break;
1300 1301
				leaf = path->nodes[0];
				nritems = btrfs_header_nritems(leaf);
C
Chris Mason 已提交
1302 1303 1304 1305 1306 1307 1308
				slot = path->slots[0];
			} else {
				slot++;
				path->slots[0]++;
			}
		}
		advance = 1;
1309 1310 1311 1312
		item = btrfs_item_nr(leaf, slot);
		btrfs_item_key_to_cpu(leaf, &found_key, slot);

		if (found_key.objectid != key.objectid)
C
Chris Mason 已提交
1313
			break;
1314
		if (btrfs_key_type(&found_key) != key_type)
C
Chris Mason 已提交
1315
			break;
1316
		if (found_key.offset < filp->f_pos)
C
Chris Mason 已提交
1317
			continue;
1318 1319

		filp->f_pos = found_key.offset;
C
Chris Mason 已提交
1320 1321 1322
		advance = 1;
		di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
		di_cur = 0;
1323
		di_total = btrfs_item_size(leaf, item);
C
Chris Mason 已提交
1324
		while(di_cur < di_total) {
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
			struct btrfs_key location;

			name_len = btrfs_dir_name_len(leaf, di);
			if (name_len < 32) {
				name_ptr = tmp_name;
			} else {
				name_ptr = kmalloc(name_len, GFP_NOFS);
				BUG_ON(!name_ptr);
			}
			read_extent_buffer(leaf, name_ptr,
					   (unsigned long)(di + 1), name_len);

			d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
			btrfs_dir_item_key_to_cpu(leaf, di, &location);

			over = filldir(dirent, name_ptr, name_len,
				       found_key.offset,
				       location.objectid,
C
Chris Mason 已提交
1343
				       d_type);
1344 1345 1346 1347

			if (name_ptr != tmp_name)
				kfree(name_ptr);

C
Chris Mason 已提交
1348 1349
			if (over)
				goto nopos;
J
Josef Bacik 已提交
1350 1351
			di_len = btrfs_dir_name_len(leaf, di) +
				btrfs_dir_data_len(leaf, di) +sizeof(*di);
C
Chris Mason 已提交
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
			di_cur += di_len;
			di = (struct btrfs_dir_item *)((char *)di + di_len);
		}
	}
	filp->f_pos++;
nopos:
	ret = 0;
err:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

int btrfs_write_inode(struct inode *inode, int wait)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;

	if (wait) {
		mutex_lock(&root->fs_info->fs_mutex);
		trans = btrfs_start_transaction(root, 1);
		btrfs_set_trans_block_group(trans, inode);
		ret = btrfs_commit_transaction(trans, root);
		mutex_unlock(&root->fs_info->fs_mutex);
	}
	return ret;
}

/*
1383
 * This is somewhat expensive, updating the tree every time the
C
Chris Mason 已提交
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
 * inode changes.  But, it is most likely to find the inode in cache.
 * FIXME, needs more benchmarking...there are no reasons other than performance
 * to keep or drop this code.
 */
void btrfs_dirty_inode(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;

	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);
	btrfs_update_inode(trans, root, inode);
	btrfs_end_transaction(trans, root);
	mutex_unlock(&root->fs_info->fs_mutex);
}

static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     u64 objectid,
				     struct btrfs_block_group_cache *group,
				     int mode)
{
	struct inode *inode;
1408
	struct btrfs_inode_item *inode_item;
C
Chris Mason 已提交
1409
	struct btrfs_key *location;
1410
	struct btrfs_path *path;
C
Chris Mason 已提交
1411 1412 1413
	int ret;
	int owner;

1414 1415 1416
	path = btrfs_alloc_path();
	BUG_ON(!path);

C
Chris Mason 已提交
1417 1418 1419 1420
	inode = new_inode(root->fs_info->sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

1421 1422
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
			     inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1423
	BTRFS_I(inode)->root = root;
1424

C
Chris Mason 已提交
1425 1426 1427 1428 1429 1430 1431
	if (mode & S_IFDIR)
		owner = 0;
	else
		owner = 1;
	group = btrfs_find_block_group(root, group, 0, 0, owner);
	BTRFS_I(inode)->block_group = group;

1432 1433 1434 1435
	ret = btrfs_insert_empty_inode(trans, root, path, objectid);
	if (ret)
		goto fail;

C
Chris Mason 已提交
1436 1437 1438 1439 1440 1441
	inode->i_uid = current->fsuid;
	inode->i_gid = current->fsgid;
	inode->i_mode = mode;
	inode->i_ino = objectid;
	inode->i_blocks = 0;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1442 1443 1444 1445 1446 1447
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				  struct btrfs_inode_item);
	fill_inode_item(path->nodes[0], inode_item, inode);
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

C
Chris Mason 已提交
1448 1449 1450 1451 1452 1453 1454
	location = &BTRFS_I(inode)->location;
	location->objectid = objectid;
	location->offset = 0;
	btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);

	insert_inode_hash(inode);
	return inode;
1455 1456 1457
fail:
	btrfs_free_path(path);
	return ERR_PTR(ret);
C
Chris Mason 已提交
1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
}

static inline u8 btrfs_inode_type(struct inode *inode)
{
	return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
}

static int btrfs_add_link(struct btrfs_trans_handle *trans,
			    struct dentry *dentry, struct inode *inode)
{
	int ret;
	struct btrfs_key key;
	struct btrfs_root *root = BTRFS_I(dentry->d_parent->d_inode)->root;
1471
	struct inode *parent_inode;
1472

C
Chris Mason 已提交
1473 1474 1475 1476 1477 1478 1479 1480 1481
	key.objectid = inode->i_ino;
	btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
	key.offset = 0;

	ret = btrfs_insert_dir_item(trans, root,
				    dentry->d_name.name, dentry->d_name.len,
				    dentry->d_parent->d_inode->i_ino,
				    &key, btrfs_inode_type(inode));
	if (ret == 0) {
1482 1483 1484 1485 1486
		ret = btrfs_insert_inode_ref(trans, root,
				     dentry->d_name.name,
				     dentry->d_name.len,
				     inode->i_ino,
				     dentry->d_parent->d_inode->i_ino);
1487 1488 1489
		parent_inode = dentry->d_parent->d_inode;
		parent_inode->i_size += dentry->d_name.len * 2;
		parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
C
Chris Mason 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
		ret = btrfs_update_inode(trans, root,
					 dentry->d_parent->d_inode);
	}
	return ret;
}

static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
			    struct dentry *dentry, struct inode *inode)
{
	int err = btrfs_add_link(trans, dentry, inode);
	if (!err) {
		d_instantiate(dentry, inode);
		return 0;
	}
	if (err > 0)
		err = -EEXIST;
	return err;
}

J
Josef Bacik 已提交
1509 1510 1511 1512 1513
static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
			int mode, dev_t rdev)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
1514
	struct inode *inode = NULL;
J
Josef Bacik 已提交
1515 1516 1517
	int err;
	int drop_inode = 0;
	u64 objectid;
1518
	unsigned long nr = 0;
J
Josef Bacik 已提交
1519 1520 1521 1522 1523

	if (!new_valid_dev(rdev))
		return -EINVAL;

	mutex_lock(&root->fs_info->fs_mutex);
1524 1525 1526 1527
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;

J
Josef Bacik 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

	inode = btrfs_new_inode(trans, root, objectid,
				BTRFS_I(dir)->block_group, mode);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

	btrfs_set_trans_block_group(trans, inode);
	err = btrfs_add_nondir(trans, dentry, inode);
	if (err)
		drop_inode = 1;
	else {
		inode->i_op = &btrfs_special_inode_operations;
		init_special_inode(inode, inode->i_mode, rdev);
1550
		btrfs_update_inode(trans, root, inode);
J
Josef Bacik 已提交
1551 1552 1553 1554 1555
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
1556
	nr = trans->blocks_used;
J
Josef Bacik 已提交
1557
	btrfs_end_transaction(trans, root);
1558
fail:
J
Josef Bacik 已提交
1559 1560 1561 1562 1563 1564
	mutex_unlock(&root->fs_info->fs_mutex);

	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
1565
	btrfs_btree_balance_dirty(root, nr);
J
Josef Bacik 已提交
1566 1567 1568
	return err;
}

C
Chris Mason 已提交
1569 1570 1571 1572 1573
static int btrfs_create(struct inode *dir, struct dentry *dentry,
			int mode, struct nameidata *nd)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
1574
	struct inode *inode = NULL;
C
Chris Mason 已提交
1575 1576
	int err;
	int drop_inode = 0;
1577
	unsigned long nr = 0;
C
Chris Mason 已提交
1578 1579 1580
	u64 objectid;

	mutex_lock(&root->fs_info->fs_mutex);
1581 1582 1583
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;
C
Chris Mason 已提交
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

	inode = btrfs_new_inode(trans, root, objectid,
				BTRFS_I(dir)->block_group, mode);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

	btrfs_set_trans_block_group(trans, inode);
	err = btrfs_add_nondir(trans, dentry, inode);
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
1607 1608
		extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
				     inode->i_mapping, GFP_NOFS);
1609
		BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
C
Chris Mason 已提交
1610 1611 1612 1613 1614
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
out_unlock:
1615
	nr = trans->blocks_used;
C
Chris Mason 已提交
1616
	btrfs_end_transaction(trans, root);
1617
fail:
C
Chris Mason 已提交
1618 1619 1620 1621 1622 1623
	mutex_unlock(&root->fs_info->fs_mutex);

	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
1624
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
1625 1626 1627 1628 1629 1630 1631 1632 1633
	return err;
}

static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
		      struct dentry *dentry)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct inode *inode = old_dentry->d_inode;
1634
	unsigned long nr = 0;
C
Chris Mason 已提交
1635 1636 1637 1638 1639 1640
	int err;
	int drop_inode = 0;

	if (inode->i_nlink == 0)
		return -ENOENT;

1641 1642 1643
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	inode->i_nlink++;
#else
C
Chris Mason 已提交
1644
	inc_nlink(inode);
1645
#endif
C
Chris Mason 已提交
1646
	mutex_lock(&root->fs_info->fs_mutex);
1647 1648 1649
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto fail;
C
Chris Mason 已提交
1650
	trans = btrfs_start_transaction(root, 1);
1651

C
Chris Mason 已提交
1652 1653 1654
	btrfs_set_trans_block_group(trans, dir);
	atomic_inc(&inode->i_count);
	err = btrfs_add_nondir(trans, dentry, inode);
1655

C
Chris Mason 已提交
1656 1657
	if (err)
		drop_inode = 1;
1658

C
Chris Mason 已提交
1659 1660
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, dir);
1661
	err = btrfs_update_inode(trans, root, inode);
1662

1663 1664
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
1665

1666
	nr = trans->blocks_used;
C
Chris Mason 已提交
1667
	btrfs_end_transaction(trans, root);
1668
fail:
C
Chris Mason 已提交
1669 1670 1671 1672 1673 1674
	mutex_unlock(&root->fs_info->fs_mutex);

	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
1675
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
	return err;
}

static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	struct inode *inode;
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	int err = 0;
	int drop_on_err = 0;
	u64 objectid;
1687
	unsigned long nr = 1;
C
Chris Mason 已提交
1688 1689

	mutex_lock(&root->fs_info->fs_mutex);
1690 1691 1692 1693
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto out_unlock;

C
Chris Mason 已提交
1694 1695
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);
1696

C
Chris Mason 已提交
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
		goto out_unlock;
	}

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

	inode = btrfs_new_inode(trans, root, objectid,
				BTRFS_I(dir)->block_group, S_IFDIR | mode);
	if (IS_ERR(inode)) {
		err = PTR_ERR(inode);
		goto out_fail;
	}
1714

C
Chris Mason 已提交
1715 1716 1717 1718 1719
	drop_on_err = 1;
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;
	btrfs_set_trans_block_group(trans, inode);

1720
	inode->i_size = 0;
C
Chris Mason 已提交
1721 1722 1723
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		goto out_fail;
1724

C
Chris Mason 已提交
1725 1726 1727
	err = btrfs_add_link(trans, dentry, inode);
	if (err)
		goto out_fail;
1728

C
Chris Mason 已提交
1729 1730 1731 1732 1733 1734 1735
	d_instantiate(dentry, inode);
	drop_on_err = 0;
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);

out_fail:
1736
	nr = trans->blocks_used;
C
Chris Mason 已提交
1737
	btrfs_end_transaction(trans, root);
1738

C
Chris Mason 已提交
1739 1740 1741 1742
out_unlock:
	mutex_unlock(&root->fs_info->fs_mutex);
	if (drop_on_err)
		iput(inode);
1743
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
1744 1745 1746
	return err;
}

1747 1748 1749 1750 1751 1752
struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
				    size_t page_offset, u64 start, u64 end,
				    int create)
{
	int ret;
	int err = 0;
1753
	u64 bytenr;
1754 1755 1756 1757 1758 1759 1760 1761
	u64 extent_start = 0;
	u64 extent_end = 0;
	u64 objectid = inode->i_ino;
	u32 found_type;
	int failed_insert = 0;
	struct btrfs_path *path;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_file_extent_item *item;
1762 1763
	struct extent_buffer *leaf;
	struct btrfs_key found_key;
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct btrfs_trans_handle *trans = NULL;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	mutex_lock(&root->fs_info->fs_mutex);

again:
	em = lookup_extent_mapping(em_tree, start, end);
	if (em) {
1775 1776 1777 1778 1779
		if (em->start > start) {
			printk("get_extent start %Lu em start %Lu\n",
			       start, em->start);
			WARN_ON(1);
		}
1780 1781 1782 1783 1784 1785 1786 1787
		goto out;
	}
	if (!em) {
		em = alloc_extent_map(GFP_NOFS);
		if (!em) {
			err = -ENOMEM;
			goto out;
		}
1788 1789
		em->start = EXTENT_MAP_HOLE;
		em->end = EXTENT_MAP_HOLE;
1790 1791
	}
	em->bdev = inode->i_sb->s_bdev;
1792 1793
	ret = btrfs_lookup_file_extent(trans, root, path,
				       objectid, start, trans != NULL);
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
	if (ret < 0) {
		err = ret;
		goto out;
	}

	if (ret != 0) {
		if (path->slots[0] == 0)
			goto not_found;
		path->slots[0]--;
	}

1805 1806
	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0],
1807 1808
			      struct btrfs_file_extent_item);
	/* are we inside the extent that was found? */
1809 1810 1811
	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
	found_type = btrfs_key_type(&found_key);
	if (found_key.objectid != objectid ||
1812 1813 1814 1815
	    found_type != BTRFS_EXTENT_DATA_KEY) {
		goto not_found;
	}

1816 1817
	found_type = btrfs_file_extent_type(leaf, item);
	extent_start = found_key.offset;
1818 1819
	if (found_type == BTRFS_FILE_EXTENT_REG) {
		extent_end = extent_start +
1820
		       btrfs_file_extent_num_bytes(leaf, item);
1821
		err = 0;
1822
		if (start < extent_start || start >= extent_end) {
1823 1824
			em->start = start;
			if (start < extent_start) {
1825 1826
				if (end < extent_start)
					goto not_found;
1827 1828 1829 1830 1831 1832
				em->end = extent_end - 1;
			} else {
				em->end = end;
			}
			goto not_found_em;
		}
1833 1834
		bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
		if (bytenr == 0) {
1835 1836
			em->start = extent_start;
			em->end = extent_end - 1;
1837 1838
			em->block_start = EXTENT_MAP_HOLE;
			em->block_end = EXTENT_MAP_HOLE;
1839 1840
			goto insert;
		}
1841 1842
		bytenr += btrfs_file_extent_offset(leaf, item);
		em->block_start = bytenr;
1843
		em->block_end = em->block_start +
1844
			btrfs_file_extent_num_bytes(leaf, item) - 1;
1845 1846 1847 1848
		em->start = extent_start;
		em->end = extent_end - 1;
		goto insert;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
1849
		unsigned long ptr;
1850
		char *map;
1851 1852 1853
		size_t size;
		size_t extent_offset;
		size_t copy_size;
1854

1855 1856
		size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
						    path->slots[0]));
1857
		extent_end = (extent_start + size - 1) |
1858
			((u64)root->sectorsize - 1);
1859
		if (start < extent_start || start >= extent_end) {
1860 1861
			em->start = start;
			if (start < extent_start) {
1862 1863
				if (end < extent_start)
					goto not_found;
1864
				em->end = extent_end;
1865 1866 1867 1868 1869
			} else {
				em->end = end;
			}
			goto not_found_em;
		}
1870 1871 1872 1873 1874 1875 1876 1877
		em->block_start = EXTENT_MAP_INLINE;
		em->block_end = EXTENT_MAP_INLINE;

		if (!page) {
			em->start = extent_start;
			em->end = extent_start + size - 1;
			goto out;
		}
1878

1879
		extent_offset = ((u64)page->index << PAGE_CACHE_SHIFT) -
1880
			extent_start + page_offset;
J
Jens Axboe 已提交
1881
		copy_size = min_t(u64, PAGE_CACHE_SIZE - page_offset,
1882 1883 1884 1885
				size - extent_offset);
		em->start = extent_start + extent_offset;
		em->end = (em->start + copy_size -1) |
			((u64)root->sectorsize -1);
1886 1887
		map = kmap(page);
		ptr = btrfs_file_extent_inline_start(item) + extent_offset;
1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
		if (create == 0 && !PageUptodate(page)) {
			read_extent_buffer(leaf, map + page_offset, ptr,
					   copy_size);
			flush_dcache_page(page);
		} else if (create && PageUptodate(page)) {
			if (!trans) {
				kunmap(page);
				free_extent_map(em);
				em = NULL;
				btrfs_release_path(root, path);
				trans = btrfs_start_transaction(root, 1);
				goto again;
			}
			write_extent_buffer(leaf, map + page_offset, ptr,
					    copy_size);
			btrfs_mark_buffer_dirty(leaf);
1904 1905
		}
		kunmap(page);
1906
		set_extent_uptodate(em_tree, em->start, em->end, GFP_NOFS);
1907 1908 1909 1910 1911 1912 1913 1914 1915
		goto insert;
	} else {
		printk("unkknown found_type %d\n", found_type);
		WARN_ON(1);
	}
not_found:
	em->start = start;
	em->end = end;
not_found_em:
1916 1917
	em->block_start = EXTENT_MAP_HOLE;
	em->block_end = EXTENT_MAP_HOLE;
1918 1919 1920
insert:
	btrfs_release_path(root, path);
	if (em->start > start || em->end < start) {
1921
		printk("bad extent! em: [%Lu %Lu] passed [%Lu %Lu]\n", em->start, em->end, start, end);
1922 1923 1924 1925 1926 1927
		err = -EIO;
		goto out;
	}
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
		free_extent_map(em);
C
Chris Mason 已提交
1928
		em = NULL;
1929 1930 1931
		if (0 && failed_insert == 1) {
			btrfs_drop_extent_cache(inode, start, end);
		}
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
		failed_insert++;
		if (failed_insert > 5) {
			printk("failing to insert %Lu %Lu\n", start, end);
			err = -EIO;
			goto out;
		}
		goto again;
	}
	err = 0;
out:
	btrfs_free_path(path);
	if (trans) {
		ret = btrfs_end_transaction(trans, root);
		if (!err)
			err = ret;
	}
	mutex_unlock(&root->fs_info->fs_mutex);
	if (err) {
		free_extent_map(em);
		WARN_ON(1);
		return ERR_PTR(err);
	}
	return em;
}

1957
static sector_t btrfs_bmap(struct address_space *mapping, sector_t iblock)
C
Chris Mason 已提交
1958
{
1959
	return extent_bmap(mapping, iblock, btrfs_get_extent);
C
Chris Mason 已提交
1960 1961
}

1962
int btrfs_readpage(struct file *file, struct page *page)
C
Chris Mason 已提交
1963
{
1964 1965 1966
	struct extent_map_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	return extent_read_full_page(tree, page, btrfs_get_extent);
C
Chris Mason 已提交
1967
}
1968

1969
static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
C
Chris Mason 已提交
1970
{
1971
	struct extent_map_tree *tree;
1972 1973 1974 1975 1976 1977 1978


	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
1979 1980
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
C
Chris Mason 已提交
1981 1982
}

C
Chris Mason 已提交
1983 1984 1985 1986 1987 1988 1989 1990
static int btrfs_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
	struct extent_map_tree *tree;
	tree = &BTRFS_I(mapping->host)->extent_tree;
	return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
}

C
Chris Mason 已提交
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
static int
btrfs_readpages(struct file *file, struct address_space *mapping,
		struct list_head *pages, unsigned nr_pages)
{
	struct extent_map_tree *tree;
	tree = &BTRFS_I(mapping->host)->extent_tree;
	return extent_readpages(tree, mapping, pages, nr_pages,
				btrfs_get_extent);
}

2001
static int btrfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
C
Chris Mason 已提交
2002
{
2003 2004
	struct extent_map_tree *tree;
	int ret;
2005

2006 2007 2008 2009 2010 2011
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	ret = try_release_extent_mapping(tree, page);
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
C
Chris Mason 已提交
2012
	}
2013
	return ret;
C
Chris Mason 已提交
2014 2015
}

2016
static void btrfs_invalidatepage(struct page *page, unsigned long offset)
C
Chris Mason 已提交
2017
{
2018
	struct extent_map_tree *tree;
C
Chris Mason 已提交
2019

2020 2021 2022
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	extent_invalidatepage(tree, page, offset);
	btrfs_releasepage(page, GFP_NOFS);
C
Chris Mason 已提交
2023 2024
}

C
Chris Mason 已提交
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
/*
 * btrfs_page_mkwrite() is not allowed to change the file size as it gets
 * called from a page fault handler when a page is first dirtied. Hence we must
 * be careful to check for EOF conditions here. We set the page up correctly
 * for a written page which means we get ENOSPC checking when writing into
 * holes and correct delalloc and unwritten extent mapping on filesystems that
 * support these features.
 *
 * We are not allowed to take the i_mutex here so we have to play games to
 * protect against truncate races as the page could now be beyond EOF.  Because
 * vmtruncate() writes the inode size before removing pages, once we have the
 * page lock we can determine safely if the page is beyond EOF. If it is not
 * beyond EOF, then the page is guaranteed safe against truncation until we
 * unlock the page.
 */
int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
{
2042
	struct inode *inode = fdentry(vma->vm_file)->d_inode;
2043
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2044 2045
	unsigned long end;
	loff_t size;
2046
	int ret;
2047
	u64 page_start;
C
Chris Mason 已提交
2048

2049 2050
	mutex_lock(&root->fs_info->fs_mutex);
	ret = btrfs_check_free_space(root, PAGE_CACHE_SIZE, 0);
2051
	mutex_unlock(&root->fs_info->fs_mutex);
2052 2053 2054 2055 2056
	if (ret)
		goto out;

	ret = -EINVAL;

2057
	down_read(&BTRFS_I(inode)->root->snap_sem);
C
Chris Mason 已提交
2058 2059 2060
	lock_page(page);
	wait_on_page_writeback(page);
	size = i_size_read(inode);
2061
	page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2062

C
Chris Mason 已提交
2063
	if ((page->mapping != inode->i_mapping) ||
2064
	    (page_start > size)) {
C
Chris Mason 已提交
2065 2066 2067 2068 2069
		/* page got truncated out from underneath us */
		goto out_unlock;
	}

	/* page is wholly or partially inside EOF */
2070
	if (page_start + PAGE_CACHE_SIZE > size)
C
Chris Mason 已提交
2071 2072 2073 2074
		end = size & ~PAGE_CACHE_MASK;
	else
		end = PAGE_CACHE_SIZE;

2075
	ret = btrfs_cow_one_page(inode, page, end);
C
Chris Mason 已提交
2076 2077

out_unlock:
2078
	up_read(&BTRFS_I(inode)->root->snap_sem);
C
Chris Mason 已提交
2079
	unlock_page(page);
2080
out:
C
Chris Mason 已提交
2081 2082 2083
	return ret;
}

C
Chris Mason 已提交
2084 2085 2086 2087 2088
static void btrfs_truncate(struct inode *inode)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret;
	struct btrfs_trans_handle *trans;
2089
	unsigned long nr;
C
Chris Mason 已提交
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104

	if (!S_ISREG(inode->i_mode))
		return;
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return;

	btrfs_truncate_page(inode->i_mapping, inode->i_size);

	mutex_lock(&root->fs_info->fs_mutex);
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, inode);

	/* FIXME, add redo link to tree so we don't leak on crash */
	ret = btrfs_truncate_in_trans(trans, root, inode);
	btrfs_update_inode(trans, root, inode);
2105
	nr = trans->blocks_used;
2106

C
Chris Mason 已提交
2107 2108 2109
	ret = btrfs_end_transaction(trans, root);
	BUG_ON(ret);
	mutex_unlock(&root->fs_info->fs_mutex);
2110
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2111 2112
}

2113 2114
static int noinline create_subvol(struct btrfs_root *root, char *name,
				  int namelen)
C
Chris Mason 已提交
2115 2116 2117 2118 2119
{
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_root_item root_item;
	struct btrfs_inode_item *inode_item;
2120
	struct extent_buffer *leaf;
C
Chris Mason 已提交
2121 2122 2123 2124
	struct btrfs_root *new_root;
	struct inode *inode;
	struct inode *dir;
	int ret;
2125
	int err;
C
Chris Mason 已提交
2126 2127
	u64 objectid;
	u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
2128
	unsigned long nr = 1;
C
Chris Mason 已提交
2129 2130

	mutex_lock(&root->fs_info->fs_mutex);
2131 2132 2133 2134
	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto fail_commit;

C
Chris Mason 已提交
2135 2136 2137
	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);

2138 2139 2140 2141 2142 2143 2144 2145
	ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
				       0, &objectid);
	if (ret)
		goto fail;

	leaf = __btrfs_alloc_free_block(trans, root, root->leafsize,
					objectid, trans->transid, 0, 0,
					0, 0);
2146 2147 2148 2149 2150
	if (IS_ERR(leaf))
		return PTR_ERR(leaf);

	btrfs_set_header_nritems(leaf, 0);
	btrfs_set_header_level(leaf, 0);
2151
	btrfs_set_header_bytenr(leaf, leaf->start);
2152
	btrfs_set_header_generation(leaf, trans->transid);
2153 2154
	btrfs_set_header_owner(leaf, objectid);

2155 2156 2157 2158
	write_extent_buffer(leaf, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(leaf),
			    BTRFS_FSID_SIZE);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2159 2160 2161

	inode_item = &root_item.inode;
	memset(inode_item, 0, sizeof(*inode_item));
2162 2163 2164 2165 2166
	inode_item->generation = cpu_to_le64(1);
	inode_item->size = cpu_to_le64(3);
	inode_item->nlink = cpu_to_le32(1);
	inode_item->nblocks = cpu_to_le64(1);
	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
C
Chris Mason 已提交
2167

2168 2169
	btrfs_set_root_bytenr(&root_item, leaf->start);
	btrfs_set_root_level(&root_item, 0);
C
Chris Mason 已提交
2170
	btrfs_set_root_refs(&root_item, 1);
2171 2172
	btrfs_set_root_used(&root_item, 0);

2173 2174
	memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress));
	root_item.drop_level = 0;
2175 2176 2177

	free_extent_buffer(leaf);
	leaf = NULL;
C
Chris Mason 已提交
2178 2179 2180 2181 2182 2183 2184 2185

	btrfs_set_root_dirid(&root_item, new_dirid);

	key.objectid = objectid;
	key.offset = 1;
	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
	ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
				&root_item);
2186 2187
	if (ret)
		goto fail;
C
Chris Mason 已提交
2188 2189 2190 2191 2192 2193 2194 2195 2196

	/*
	 * insert the directory item
	 */
	key.offset = (u64)-1;
	dir = root->fs_info->sb->s_root->d_inode;
	ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
				    name, namelen, dir->i_ino, &key,
				    BTRFS_FT_DIR);
2197 2198
	if (ret)
		goto fail;
C
Chris Mason 已提交
2199

2200 2201 2202 2203 2204 2205
	ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
			     name, namelen, objectid,
			     root->fs_info->sb->s_root->d_inode->i_ino);
	if (ret)
		goto fail;

C
Chris Mason 已提交
2206
	ret = btrfs_commit_transaction(trans, root);
2207 2208
	if (ret)
		goto fail_commit;
C
Chris Mason 已提交
2209

2210
	new_root = btrfs_read_fs_root(root->fs_info, &key, name, namelen);
C
Chris Mason 已提交
2211 2212 2213 2214 2215 2216 2217
	BUG_ON(!new_root);

	trans = btrfs_start_transaction(new_root, 1);
	BUG_ON(!trans);

	inode = btrfs_new_inode(trans, new_root, new_dirid,
				BTRFS_I(dir)->block_group, S_IFDIR | 0700);
2218 2219
	if (IS_ERR(inode))
		goto fail;
C
Chris Mason 已提交
2220 2221
	inode->i_op = &btrfs_dir_inode_operations;
	inode->i_fop = &btrfs_dir_file_operations;
C
Chris Mason 已提交
2222
	new_root->inode = inode;
C
Chris Mason 已提交
2223

2224 2225
	ret = btrfs_insert_inode_ref(trans, new_root, "..", 2, new_dirid,
				     new_dirid);
C
Chris Mason 已提交
2226
	inode->i_nlink = 1;
2227
	inode->i_size = 0;
C
Chris Mason 已提交
2228
	ret = btrfs_update_inode(trans, new_root, inode);
2229 2230 2231
	if (ret)
		goto fail;
fail:
2232
	nr = trans->blocks_used;
2233 2234 2235 2236
	err = btrfs_commit_transaction(trans, root);
	if (err && !ret)
		ret = err;
fail_commit:
C
Chris Mason 已提交
2237
	mutex_unlock(&root->fs_info->fs_mutex);
2238
	btrfs_btree_balance_dirty(root, nr);
2239
	return ret;
C
Chris Mason 已提交
2240 2241 2242 2243 2244 2245 2246
}

static int create_snapshot(struct btrfs_root *root, char *name, int namelen)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_root_item new_root_item;
2247
	struct extent_buffer *tmp;
C
Chris Mason 已提交
2248
	int ret;
2249
	int err;
C
Chris Mason 已提交
2250
	u64 objectid;
2251
	unsigned long nr = 0;
C
Chris Mason 已提交
2252 2253 2254 2255

	if (!root->ref_cows)
		return -EINVAL;

2256 2257 2258 2259
	down_write(&root->snap_sem);
	freeze_bdev(root->fs_info->sb->s_bdev);
	thaw_bdev(root->fs_info->sb->s_bdev, root->fs_info->sb);

C
Chris Mason 已提交
2260
	mutex_lock(&root->fs_info->fs_mutex);
2261 2262 2263 2264
	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto fail_unlock;

C
Chris Mason 已提交
2265 2266 2267 2268
	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);

	ret = btrfs_update_inode(trans, root, root->inode);
2269 2270
	if (ret)
		goto fail;
C
Chris Mason 已提交
2271 2272 2273

	ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
				       0, &objectid);
2274 2275
	if (ret)
		goto fail;
C
Chris Mason 已提交
2276 2277 2278 2279 2280 2281 2282

	memcpy(&new_root_item, &root->root_item,
	       sizeof(new_root_item));

	key.objectid = objectid;
	key.offset = 1;
	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
2283

2284
	extent_buffer_get(root->node);
2285
	btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
2286
	free_extent_buffer(tmp);
2287 2288 2289 2290 2291

	btrfs_copy_root(trans, root, root->node, &tmp, objectid);

	btrfs_set_root_bytenr(&new_root_item, tmp->start);
	btrfs_set_root_level(&new_root_item, btrfs_header_level(tmp));
C
Chris Mason 已提交
2292 2293
	ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
				&new_root_item);
2294
	free_extent_buffer(tmp);
2295 2296
	if (ret)
		goto fail;
C
Chris Mason 已提交
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306

	/*
	 * insert the directory item
	 */
	key.offset = (u64)-1;
	ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
				    name, namelen,
				    root->fs_info->sb->s_root->d_inode->i_ino,
				    &key, BTRFS_FT_DIR);

2307 2308
	if (ret)
		goto fail;
C
Chris Mason 已提交
2309

2310 2311 2312 2313 2314 2315
	ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
			     name, namelen, objectid,
			     root->fs_info->sb->s_root->d_inode->i_ino);

	if (ret)
		goto fail;
2316
fail:
2317
	nr = trans->blocks_used;
2318
	err = btrfs_commit_transaction(trans, root);
2319

2320 2321
	if (err && !ret)
		ret = err;
2322
fail_unlock:
C
Chris Mason 已提交
2323
	mutex_unlock(&root->fs_info->fs_mutex);
2324
	up_write(&root->snap_sem);
2325
	btrfs_btree_balance_dirty(root, nr);
2326
	return ret;
C
Chris Mason 已提交
2327 2328
}

2329
unsigned long btrfs_force_ra(struct address_space *mapping,
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
			      struct file_ra_state *ra, struct file *file,
			      pgoff_t offset, pgoff_t last_index)
{
	pgoff_t req_size;

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
	req_size = last_index - offset + 1;
	offset = page_cache_readahead(mapping, ra, file, offset, req_size);
	return offset;
#else
	req_size = min(last_index - offset + 1, (pgoff_t)128);
	page_cache_sync_readahead(mapping, ra, file, offset, req_size);
	return offset + req_size;
#endif
}

int btrfs_defrag_file(struct file *file) {
2347
	struct inode *inode = fdentry(file)->d_inode;
2348
	struct btrfs_root *root = BTRFS_I(inode)->root;
2349 2350 2351 2352 2353 2354
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct page *page;
	unsigned long last_index;
	unsigned long ra_index = 0;
	u64 page_start;
	u64 page_end;
2355 2356
	u64 delalloc_start;
	u64 existing_delalloc;
2357
	unsigned long i;
2358 2359 2360 2361 2362 2363 2364
	int ret;

	mutex_lock(&root->fs_info->fs_mutex);
	ret = btrfs_check_free_space(root, inode->i_size, 0);
	mutex_unlock(&root->fs_info->fs_mutex);
	if (ret)
		return -ENOSPC;
2365 2366 2367 2368 2369

	mutex_lock(&inode->i_mutex);
	last_index = inode->i_size >> PAGE_CACHE_SHIFT;
	for (i = 0; i <= last_index; i++) {
		if (i == ra_index) {
2370 2371 2372
			ra_index = btrfs_force_ra(inode->i_mapping,
						  &file->f_ra,
						  file, ra_index, last_index);
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
		}
		page = grab_cache_page(inode->i_mapping, i);
		if (!page)
			goto out_unlock;
		if (!PageUptodate(page)) {
			btrfs_readpage(NULL, page);
			lock_page(page);
			if (!PageUptodate(page)) {
				unlock_page(page);
				page_cache_release(page);
				goto out_unlock;
			}
		}
2386
		page_start = (u64)page->index << PAGE_CACHE_SHIFT;
2387 2388 2389
		page_end = page_start + PAGE_CACHE_SIZE - 1;

		lock_extent(em_tree, page_start, page_end, GFP_NOFS);
2390 2391 2392 2393 2394
		delalloc_start = page_start;
		existing_delalloc =
			count_range_bits(&BTRFS_I(inode)->extent_tree,
					 &delalloc_start, page_end,
					 PAGE_CACHE_SIZE, EXTENT_DELALLOC);
2395 2396
		set_extent_delalloc(em_tree, page_start,
				    page_end, GFP_NOFS);
2397 2398 2399 2400 2401 2402

		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->delalloc_bytes += PAGE_CACHE_SIZE -
						 existing_delalloc;
		spin_unlock(&root->fs_info->delalloc_lock);

2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414
		unlock_extent(em_tree, page_start, page_end, GFP_NOFS);
		set_page_dirty(page);
		unlock_page(page);
		page_cache_release(page);
		balance_dirty_pages_ratelimited_nr(inode->i_mapping, 1);
	}

out_unlock:
	mutex_unlock(&inode->i_mutex);
	return 0;
}

2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479
static int btrfs_ioctl_resize(struct btrfs_root *root, void __user *arg)
{
	u64 new_size;
	u64 old_size;
	struct btrfs_ioctl_vol_args *vol_args;
	struct btrfs_trans_handle *trans;
	char *sizestr;
	int ret = 0;
	int namelen;
	int mod = 0;

	vol_args = kmalloc(sizeof(*vol_args), GFP_NOFS);

	if (!vol_args)
		return -ENOMEM;

	if (copy_from_user(vol_args, arg, sizeof(*vol_args))) {
		ret = -EFAULT;
		goto out;
	}
	namelen = strlen(vol_args->name);
	if (namelen > BTRFS_VOL_NAME_MAX) {
		ret = -EINVAL;
		goto out;
	}

	sizestr = vol_args->name;
	if (!strcmp(sizestr, "max"))
		new_size = root->fs_info->sb->s_bdev->bd_inode->i_size;
	else {
		if (sizestr[0] == '-') {
			mod = -1;
			sizestr++;
		} else if (sizestr[0] == '+') {
			mod = 1;
			sizestr++;
		}
		new_size = btrfs_parse_size(sizestr);
		if (new_size == 0) {
			ret = -EINVAL;
			goto out;
		}
	}

	mutex_lock(&root->fs_info->fs_mutex);
	old_size = btrfs_super_total_bytes(&root->fs_info->super_copy);

	if (mod < 0) {
		if (new_size > old_size) {
			ret = -EINVAL;
			goto out_unlock;
		}
		new_size = old_size - new_size;
	} else if (mod > 0) {
		new_size = old_size + new_size;
	}

	if (new_size < 256 * 1024 * 1024) {
		ret = -EINVAL;
		goto out_unlock;
	}
	if (new_size > root->fs_info->sb->s_bdev->bd_inode->i_size) {
		ret = -EFBIG;
		goto out_unlock;
	}
2480 2481 2482

	do_div(new_size, root->sectorsize);
	new_size *= root->sectorsize;
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499

printk("new size is %Lu\n", new_size);
	if (new_size > old_size) {
		trans = btrfs_start_transaction(root, 1);
		ret = btrfs_grow_extent_tree(trans, root, new_size);
		btrfs_commit_transaction(trans, root);
	} else {
		ret = btrfs_shrink_extent_tree(root, new_size);
	}

out_unlock:
	mutex_unlock(&root->fs_info->fs_mutex);
out:
	kfree(vol_args);
	return ret;
}

2500 2501
static int noinline btrfs_ioctl_snap_create(struct btrfs_root *root,
					    void __user *arg)
C
Chris Mason 已提交
2502
{
2503
	struct btrfs_ioctl_vol_args *vol_args;
C
Chris Mason 已提交
2504 2505 2506
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	u64 root_dirid;
2507 2508
	int namelen;
	int ret;
C
Chris Mason 已提交
2509

2510
	vol_args = kmalloc(sizeof(*vol_args), GFP_NOFS);
2511

2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
	if (!vol_args)
		return -ENOMEM;

	if (copy_from_user(vol_args, arg, sizeof(*vol_args))) {
		ret = -EFAULT;
		goto out;
	}

	namelen = strlen(vol_args->name);
	if (namelen > BTRFS_VOL_NAME_MAX) {
		ret = -EINVAL;
		goto out;
	}
	if (strchr(vol_args->name, '/')) {
		ret = -EINVAL;
		goto out;
	}
C
Christoph Hellwig 已提交
2529 2530

	path = btrfs_alloc_path();
2531 2532 2533 2534
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}
C
Christoph Hellwig 已提交
2535 2536 2537 2538 2539

	root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
	mutex_lock(&root->fs_info->fs_mutex);
	di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
			    path, root_dirid,
2540
			    vol_args->name, namelen, 0);
C
Christoph Hellwig 已提交
2541 2542
	mutex_unlock(&root->fs_info->fs_mutex);
	btrfs_free_path(path);
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552

	if (di && !IS_ERR(di)) {
		ret = -EEXIST;
		goto out;
	}

	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto out;
	}
C
Christoph Hellwig 已提交
2553 2554

	if (root == root->fs_info->tree_root)
2555 2556 2557 2558 2559 2560
		ret = create_subvol(root, vol_args->name, namelen);
	else
		ret = create_snapshot(root, vol_args->name, namelen);
out:
	kfree(vol_args);
	return ret;
C
Christoph Hellwig 已提交
2561 2562 2563 2564
}

static int btrfs_ioctl_defrag(struct file *file)
{
2565
	struct inode *inode = fdentry(file)->d_inode;
C
Christoph Hellwig 已提交
2566 2567 2568 2569
	struct btrfs_root *root = BTRFS_I(inode)->root;

	switch (inode->i_mode & S_IFMT) {
	case S_IFDIR:
C
Chris Mason 已提交
2570
		mutex_lock(&root->fs_info->fs_mutex);
C
Christoph Hellwig 已提交
2571 2572
		btrfs_defrag_root(root, 0);
		btrfs_defrag_root(root->fs_info->extent_root, 0);
C
Chris Mason 已提交
2573 2574
		mutex_unlock(&root->fs_info->fs_mutex);
		break;
C
Christoph Hellwig 已提交
2575 2576 2577 2578 2579 2580 2581
	case S_IFREG:
		btrfs_defrag_file(file);
		break;
	}

	return 0;
}
2582

C
Christoph Hellwig 已提交
2583 2584 2585
long btrfs_ioctl(struct file *file, unsigned int
		cmd, unsigned long arg)
{
2586
	struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
C
Christoph Hellwig 已提交
2587 2588 2589 2590

	switch (cmd) {
	case BTRFS_IOC_SNAP_CREATE:
		return btrfs_ioctl_snap_create(root, (void __user *)arg);
2591
	case BTRFS_IOC_DEFRAG:
C
Christoph Hellwig 已提交
2592
		return btrfs_ioctl_defrag(file);
2593 2594
	case BTRFS_IOC_RESIZE:
		return btrfs_ioctl_resize(root, (void __user *)arg);
C
Chris Mason 已提交
2595
	}
C
Christoph Hellwig 已提交
2596 2597

	return -ENOTTY;
C
Chris Mason 已提交
2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
}

/*
 * Called inside transaction, so use GFP_NOFS
 */
struct inode *btrfs_alloc_inode(struct super_block *sb)
{
	struct btrfs_inode *ei;

	ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
	if (!ei)
		return NULL;
2610
	ei->last_trans = 0;
C
Chris Mason 已提交
2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
	return &ei->vfs_inode;
}

void btrfs_destroy_inode(struct inode *inode)
{
	WARN_ON(!list_empty(&inode->i_dentry));
	WARN_ON(inode->i_data.nrpages);

	kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
}

2622 2623 2624
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
static void init_once(struct kmem_cache * cachep, void *foo)
#else
C
Chris Mason 已提交
2625 2626
static void init_once(void * foo, struct kmem_cache * cachep,
		      unsigned long flags)
2627
#endif
C
Chris Mason 已提交
2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647
{
	struct btrfs_inode *ei = (struct btrfs_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

void btrfs_destroy_cachep(void)
{
	if (btrfs_inode_cachep)
		kmem_cache_destroy(btrfs_inode_cachep);
	if (btrfs_trans_handle_cachep)
		kmem_cache_destroy(btrfs_trans_handle_cachep);
	if (btrfs_transaction_cachep)
		kmem_cache_destroy(btrfs_transaction_cachep);
	if (btrfs_bit_radix_cachep)
		kmem_cache_destroy(btrfs_bit_radix_cachep);
	if (btrfs_path_cachep)
		kmem_cache_destroy(btrfs_path_cachep);
}

2648
struct kmem_cache *btrfs_cache_create(const char *name, size_t size,
2649
				       unsigned long extra_flags,
2650 2651 2652
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
				       void (*ctor)(struct kmem_cache *, void *)
#else
2653
				       void (*ctor)(void *, struct kmem_cache *,
2654 2655 2656
						    unsigned long)
#endif
				     )
2657 2658 2659 2660 2661 2662 2663 2664 2665
{
	return kmem_cache_create(name, size, 0, (SLAB_RECLAIM_ACCOUNT |
				 SLAB_MEM_SPREAD | extra_flags), ctor
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
				 ,NULL
#endif
				);
}

C
Chris Mason 已提交
2666 2667
int btrfs_init_cachep(void)
{
2668
	btrfs_inode_cachep = btrfs_cache_create("btrfs_inode_cache",
2669 2670
					  sizeof(struct btrfs_inode),
					  0, init_once);
C
Chris Mason 已提交
2671 2672
	if (!btrfs_inode_cachep)
		goto fail;
2673 2674 2675 2676
	btrfs_trans_handle_cachep =
			btrfs_cache_create("btrfs_trans_handle_cache",
					   sizeof(struct btrfs_trans_handle),
					   0, NULL);
C
Chris Mason 已提交
2677 2678
	if (!btrfs_trans_handle_cachep)
		goto fail;
2679
	btrfs_transaction_cachep = btrfs_cache_create("btrfs_transaction_cache",
C
Chris Mason 已提交
2680
					     sizeof(struct btrfs_transaction),
2681
					     0, NULL);
C
Chris Mason 已提交
2682 2683
	if (!btrfs_transaction_cachep)
		goto fail;
2684
	btrfs_path_cachep = btrfs_cache_create("btrfs_path_cache",
2685
					 sizeof(struct btrfs_path),
2686
					 0, NULL);
C
Chris Mason 已提交
2687 2688
	if (!btrfs_path_cachep)
		goto fail;
2689
	btrfs_bit_radix_cachep = btrfs_cache_create("btrfs_radix", 256,
2690
					      SLAB_DESTROY_BY_RCU, NULL);
C
Chris Mason 已提交
2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
	if (!btrfs_bit_radix_cachep)
		goto fail;
	return 0;
fail:
	btrfs_destroy_cachep();
	return -ENOMEM;
}

static int btrfs_getattr(struct vfsmount *mnt,
			 struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
	generic_fillattr(inode, stat);
	stat->blksize = 256 * 1024;
	return 0;
}

static int btrfs_rename(struct inode * old_dir, struct dentry *old_dentry,
			   struct inode * new_dir,struct dentry *new_dentry)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(old_dir)->root;
	struct inode *new_inode = new_dentry->d_inode;
	struct inode *old_inode = old_dentry->d_inode;
	struct timespec ctime = CURRENT_TIME;
	struct btrfs_path *path;
	int ret;

	if (S_ISDIR(old_inode->i_mode) && new_inode &&
	    new_inode->i_size > BTRFS_EMPTY_DIR_SIZE) {
		return -ENOTEMPTY;
	}
2723

C
Chris Mason 已提交
2724
	mutex_lock(&root->fs_info->fs_mutex);
2725 2726 2727 2728
	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto out_unlock;

C
Chris Mason 已提交
2729
	trans = btrfs_start_transaction(root, 1);
2730

C
Chris Mason 已提交
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
	btrfs_set_trans_block_group(trans, new_dir);
	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out_fail;
	}

	old_dentry->d_inode->i_nlink++;
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	old_inode->i_ctime = ctime;
2742

C
Chris Mason 已提交
2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759
	ret = btrfs_unlink_trans(trans, root, old_dir, old_dentry);
	if (ret)
		goto out_fail;

	if (new_inode) {
		new_inode->i_ctime = CURRENT_TIME;
		ret = btrfs_unlink_trans(trans, root, new_dir, new_dentry);
		if (ret)
			goto out_fail;
	}
	ret = btrfs_add_link(trans, new_dentry, old_inode);
	if (ret)
		goto out_fail;

out_fail:
	btrfs_free_path(path);
	btrfs_end_transaction(trans, root);
2760
out_unlock:
C
Chris Mason 已提交
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
	mutex_unlock(&root->fs_info->fs_mutex);
	return ret;
}

static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
			 const char *symname)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_path *path;
	struct btrfs_key key;
2772
	struct inode *inode = NULL;
C
Chris Mason 已提交
2773 2774 2775 2776 2777
	int err;
	int drop_inode = 0;
	u64 objectid;
	int name_len;
	int datasize;
2778
	unsigned long ptr;
C
Chris Mason 已提交
2779
	struct btrfs_file_extent_item *ei;
2780
	struct extent_buffer *leaf;
2781
	unsigned long nr = 0;
C
Chris Mason 已提交
2782 2783 2784 2785

	name_len = strlen(symname) + 1;
	if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
		return -ENAMETOOLONG;
2786

C
Chris Mason 已提交
2787
	mutex_lock(&root->fs_info->fs_mutex);
2788 2789 2790 2791
	err = btrfs_check_free_space(root, 1, 0);
	if (err)
		goto out_fail;

C
Chris Mason 已提交
2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
	trans = btrfs_start_transaction(root, 1);
	btrfs_set_trans_block_group(trans, dir);

	err = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
	if (err) {
		err = -ENOSPC;
		goto out_unlock;
	}

	inode = btrfs_new_inode(trans, root, objectid,
				BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO);
	err = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_unlock;

	btrfs_set_trans_block_group(trans, inode);
	err = btrfs_add_nondir(trans, dentry, inode);
	if (err)
		drop_inode = 1;
	else {
		inode->i_mapping->a_ops = &btrfs_aops;
		inode->i_fop = &btrfs_file_operations;
		inode->i_op = &btrfs_file_inode_operations;
2815 2816
		extent_map_tree_init(&BTRFS_I(inode)->extent_tree,
				     inode->i_mapping, GFP_NOFS);
2817
		BTRFS_I(inode)->extent_tree.ops = &btrfs_extent_map_ops;
C
Chris Mason 已提交
2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
	}
	dir->i_sb->s_dirt = 1;
	btrfs_update_inode_block_group(trans, inode);
	btrfs_update_inode_block_group(trans, dir);
	if (drop_inode)
		goto out_unlock;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	key.objectid = inode->i_ino;
	key.offset = 0;
	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
	datasize = btrfs_file_extent_calc_inline_size(name_len);
	err = btrfs_insert_empty_item(trans, root, path, &key,
				      datasize);
2833 2834 2835 2836
	if (err) {
		drop_inode = 1;
		goto out_unlock;
	}
2837 2838 2839 2840 2841
	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,
C
Chris Mason 已提交
2842 2843
				   BTRFS_FILE_EXTENT_INLINE);
	ptr = btrfs_file_extent_inline_start(ei);
2844 2845
	write_extent_buffer(leaf, symname, ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
C
Chris Mason 已提交
2846
	btrfs_free_path(path);
2847

C
Chris Mason 已提交
2848 2849 2850
	inode->i_op = &btrfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &btrfs_symlink_aops;
	inode->i_size = name_len - 1;
2851 2852 2853
	err = btrfs_update_inode(trans, root, inode);
	if (err)
		drop_inode = 1;
C
Chris Mason 已提交
2854 2855

out_unlock:
2856
	nr = trans->blocks_used;
C
Chris Mason 已提交
2857
	btrfs_end_transaction(trans, root);
2858
out_fail:
C
Chris Mason 已提交
2859 2860 2861 2862 2863
	mutex_unlock(&root->fs_info->fs_mutex);
	if (drop_inode) {
		inode_dec_link_count(inode);
		iput(inode);
	}
2864
	btrfs_btree_balance_dirty(root, nr);
C
Chris Mason 已提交
2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
	return err;
}

static struct inode_operations btrfs_dir_inode_operations = {
	.lookup		= btrfs_lookup,
	.create		= btrfs_create,
	.unlink		= btrfs_unlink,
	.link		= btrfs_link,
	.mkdir		= btrfs_mkdir,
	.rmdir		= btrfs_rmdir,
	.rename		= btrfs_rename,
	.symlink	= btrfs_symlink,
	.setattr	= btrfs_setattr,
J
Josef Bacik 已提交
2878
	.mknod		= btrfs_mknod,
J
Josef Bacik 已提交
2879 2880 2881 2882
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= btrfs_listxattr,
	.removexattr	= generic_removexattr,
C
Chris Mason 已提交
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892
};

static struct inode_operations btrfs_dir_ro_inode_operations = {
	.lookup		= btrfs_lookup,
};

static struct file_operations btrfs_dir_file_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
	.readdir	= btrfs_readdir,
C
Christoph Hellwig 已提交
2893
	.unlocked_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
2894
#ifdef CONFIG_COMPAT
C
Christoph Hellwig 已提交
2895
	.compat_ioctl	= btrfs_ioctl,
C
Chris Mason 已提交
2896 2897 2898
#endif
};

2899 2900 2901 2902 2903 2904 2905
static struct extent_map_ops btrfs_extent_map_ops = {
	.fill_delalloc = run_delalloc_range,
	.writepage_io_hook = btrfs_writepage_io_hook,
	.readpage_io_hook = btrfs_readpage_io_hook,
	.readpage_end_io_hook = btrfs_readpage_end_io_hook,
};

C
Chris Mason 已提交
2906 2907 2908
static struct address_space_operations btrfs_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
2909
	.writepages	= btrfs_writepages,
C
Chris Mason 已提交
2910
	.readpages	= btrfs_readpages,
C
Chris Mason 已提交
2911 2912
	.sync_page	= block_sync_page,
	.bmap		= btrfs_bmap,
2913 2914 2915
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
	.set_page_dirty	= __set_page_dirty_nobuffers,
C
Chris Mason 已提交
2916 2917 2918 2919 2920
};

static struct address_space_operations btrfs_symlink_aops = {
	.readpage	= btrfs_readpage,
	.writepage	= btrfs_writepage,
C
Chris Mason 已提交
2921 2922
	.invalidatepage = btrfs_invalidatepage,
	.releasepage	= btrfs_releasepage,
C
Chris Mason 已提交
2923 2924 2925 2926 2927 2928
};

static struct inode_operations btrfs_file_inode_operations = {
	.truncate	= btrfs_truncate,
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
J
Josef Bacik 已提交
2929 2930 2931 2932
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr      = btrfs_listxattr,
	.removexattr	= generic_removexattr,
C
Chris Mason 已提交
2933 2934
};

J
Josef Bacik 已提交
2935 2936 2937 2938 2939
static struct inode_operations btrfs_special_inode_operations = {
	.getattr	= btrfs_getattr,
	.setattr	= btrfs_setattr,
};

C
Chris Mason 已提交
2940 2941 2942 2943 2944
static struct inode_operations btrfs_symlink_inode_operations = {
	.readlink	= generic_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
};