ioctl.c 27.3 KB
Newer Older
C
Christoph Hellwig 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * 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.
 */

#include <linux/kernel.h>
#include <linux/bio.h>
#include <linux/buffer_head.h>
#include <linux/file.h>
#include <linux/fs.h>
24
#include <linux/fsnotify.h>
C
Christoph Hellwig 已提交
25 26 27 28 29 30 31
#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>
32
#include <linux/mount.h>
C
Christoph Hellwig 已提交
33
#include <linux/mpage.h>
34
#include <linux/namei.h>
C
Christoph Hellwig 已提交
35 36 37 38 39
#include <linux/swap.h>
#include <linux/writeback.h>
#include <linux/statfs.h>
#include <linux/compat.h>
#include <linux/bit_spinlock.h>
40
#include <linux/security.h>
C
Christoph Hellwig 已提交
41 42
#include <linux/version.h>
#include <linux/xattr.h>
43
#include <linux/vmalloc.h>
C
Chris Mason 已提交
44
#include "compat.h"
C
Christoph Hellwig 已提交
45 46 47 48 49 50 51
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "ioctl.h"
#include "print-tree.h"
#include "volumes.h"
52
#include "locking.h"
C
Christoph Hellwig 已提交
53 54 55



56 57 58
static noinline int create_subvol(struct btrfs_root *root,
				  struct dentry *dentry,
				  char *name, int namelen)
C
Christoph Hellwig 已提交
59 60 61 62 63 64 65 66 67 68 69 70
{
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_root_item root_item;
	struct btrfs_inode_item *inode_item;
	struct extent_buffer *leaf;
	struct btrfs_root *new_root = root;
	struct inode *dir;
	int ret;
	int err;
	u64 objectid;
	u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
71
	u64 index = 0;
C
Christoph Hellwig 已提交
72 73 74 75 76 77 78 79 80 81 82 83 84 85
	unsigned long nr = 1;

	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto fail_commit;

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

	ret = btrfs_find_free_objectid(trans, root->fs_info->tree_root,
				       0, &objectid);
	if (ret)
		goto fail;

Z
Zheng Yan 已提交
86 87
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
				      objectid, trans->transid, 0, 0, 0);
88 89 90 91
	if (IS_ERR(leaf)) {
		ret = PTR_ERR(leaf);
		goto fail;
	}
C
Christoph Hellwig 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

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

	write_extent_buffer(leaf, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(leaf),
			    BTRFS_FSID_SIZE);
	btrfs_mark_buffer_dirty(leaf);

	inode_item = &root_item.inode;
	memset(inode_item, 0, sizeof(*inode_item));
	inode_item->generation = cpu_to_le64(1);
	inode_item->size = cpu_to_le64(3);
	inode_item->nlink = cpu_to_le32(1);
109
	inode_item->nbytes = cpu_to_le64(root->leafsize);
C
Christoph Hellwig 已提交
110 111 112
	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);

	btrfs_set_root_bytenr(&root_item, leaf->start);
113
	btrfs_set_root_generation(&root_item, trans->transid);
C
Christoph Hellwig 已提交
114 115 116
	btrfs_set_root_level(&root_item, 0);
	btrfs_set_root_refs(&root_item, 1);
	btrfs_set_root_used(&root_item, 0);
Y
Yan Zheng 已提交
117
	btrfs_set_root_last_snapshot(&root_item, 0);
C
Christoph Hellwig 已提交
118 119 120 121

	memset(&root_item.drop_progress, 0, sizeof(root_item.drop_progress));
	root_item.drop_level = 0;

122
	btrfs_tree_unlock(leaf);
C
Christoph Hellwig 已提交
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
	free_extent_buffer(leaf);
	leaf = NULL;

	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);
	if (ret)
		goto fail;

	/*
	 * insert the directory item
	 */
	key.offset = (u64)-1;
140 141 142 143 144
	dir = dentry->d_parent->d_inode;
	ret = btrfs_set_inode_index(dir, &index);
	BUG_ON(ret);

	ret = btrfs_insert_dir_item(trans, root,
C
Christoph Hellwig 已提交
145
				    name, namelen, dir->i_ino, &key,
146
				    BTRFS_FT_DIR, index);
C
Christoph Hellwig 已提交
147 148
	if (ret)
		goto fail;
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

	/* add the backref first */
	ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
				 objectid, BTRFS_ROOT_BACKREF_KEY,
				 root->root_key.objectid,
				 dir->i_ino, index, name, namelen);

	BUG_ON(ret);

	/* now add the forward ref */
	ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
				 root->root_key.objectid, BTRFS_ROOT_REF_KEY,
				 objectid,
				 dir->i_ino, index, name, namelen);

	BUG_ON(ret);

C
Christoph Hellwig 已提交
166 167 168 169
	ret = btrfs_commit_transaction(trans, root);
	if (ret)
		goto fail_commit;

170
	new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
C
Christoph Hellwig 已提交
171 172 173 174 175
	BUG_ON(!new_root);

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

176
	ret = btrfs_create_subvol_root(trans, new_root, dentry, new_dirid,
C
Christoph Hellwig 已提交
177 178 179 180 181 182 183 184 185 186 187 188 189 190
				       BTRFS_I(dir)->block_group);
	if (ret)
		goto fail;

fail:
	nr = trans->blocks_used;
	err = btrfs_commit_transaction(trans, new_root);
	if (err && !ret)
		ret = err;
fail_commit:
	btrfs_btree_balance_dirty(root, nr);
	return ret;
}

191 192
static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
			   char *name, int namelen)
C
Christoph Hellwig 已提交
193 194 195
{
	struct btrfs_pending_snapshot *pending_snapshot;
	struct btrfs_trans_handle *trans;
196
	int ret = 0;
C
Christoph Hellwig 已提交
197 198 199 200 201 202 203 204 205 206
	int err;
	unsigned long nr = 0;

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

	ret = btrfs_check_free_space(root, 1, 0);
	if (ret)
		goto fail_unlock;

207
	pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
C
Christoph Hellwig 已提交
208 209 210 211 212 213 214 215 216 217 218 219
	if (!pending_snapshot) {
		ret = -ENOMEM;
		goto fail_unlock;
	}
	pending_snapshot->name = kmalloc(namelen + 1, GFP_NOFS);
	if (!pending_snapshot->name) {
		ret = -ENOMEM;
		kfree(pending_snapshot);
		goto fail_unlock;
	}
	memcpy(pending_snapshot->name, name, namelen);
	pending_snapshot->name[namelen] = '\0';
220
	pending_snapshot->dentry = dentry;
C
Christoph Hellwig 已提交
221 222 223 224 225 226 227 228 229 230 231 232
	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);
	pending_snapshot->root = root;
	list_add(&pending_snapshot->list,
		 &trans->transaction->pending_snapshots);
	err = btrfs_commit_transaction(trans, root);

fail_unlock:
	btrfs_btree_balance_dirty(root, nr);
	return ret;
}

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/* copy of may_create in fs/namei.c() */
static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
{
	if (child->d_inode)
		return -EEXIST;
	if (IS_DEADDIR(dir))
		return -ENOENT;
	return inode_permission(dir, MAY_WRITE | MAY_EXEC);
}

/*
 * Create a new subvolume below @parent.  This is largely modeled after
 * sys_mkdirat and vfs_mkdir, but we only do a single component lookup
 * inside this filesystem so it's quite a bit simpler.
 */
static noinline int btrfs_mksubvol(struct path *parent, char *name,
249 250
				   int mode, int namelen,
				   struct btrfs_root *snap_src)
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
{
	struct dentry *dentry;
	int error;

	mutex_lock_nested(&parent->dentry->d_inode->i_mutex, I_MUTEX_PARENT);

	dentry = lookup_one_len(name, parent->dentry, namelen);
	error = PTR_ERR(dentry);
	if (IS_ERR(dentry))
		goto out_unlock;

	error = -EEXIST;
	if (dentry->d_inode)
		goto out_dput;

	if (!IS_POSIXACL(parent->dentry->d_inode))
		mode &= ~current->fs->umask;
268

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
	error = mnt_want_write(parent->mnt);
	if (error)
		goto out_dput;

	error = btrfs_may_create(parent->dentry->d_inode, dentry);
	if (error)
		goto out_drop_write;

	/*
	 * Actually perform the low-level subvolume creation after all
	 * this VFS fuzz.
	 *
	 * Eventually we want to pass in an inode under which we create this
	 * subvolume, but for now all are under the filesystem root.
	 *
	 * Also we should pass on the mode eventually to allow creating new
	 * subvolume with specific mode bits.
	 */
287
	if (snap_src) {
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
		struct dentry *dir = dentry->d_parent;
		struct dentry *test = dir->d_parent;
		struct btrfs_path *path = btrfs_alloc_path();
		int ret;
		u64 test_oid;
		u64 parent_oid = BTRFS_I(dir->d_inode)->root->root_key.objectid;

		test_oid = snap_src->root_key.objectid;

		ret = btrfs_find_root_ref(snap_src->fs_info->tree_root,
					  path, parent_oid, test_oid);
		if (ret == 0)
			goto create;
		btrfs_release_path(snap_src->fs_info->tree_root, path);

		/* we need to make sure we aren't creating a directory loop
		 * by taking a snapshot of something that has our current
		 * subvol in its directory tree.  So, this loops through
		 * the dentries and checks the forward refs for each subvolume
		 * to see if is references the subvolume where we are
		 * placing this new snapshot.
		 */
		while(1) {
			if (!test ||
			    dir == snap_src->fs_info->sb->s_root ||
			    test == snap_src->fs_info->sb->s_root ||
			    test->d_inode->i_sb != snap_src->fs_info->sb) {
				break;
			}
			if (S_ISLNK(test->d_inode->i_mode)) {
				printk("Symlink in snapshot path, failed\n");
				error = -EMLINK;
				btrfs_free_path(path);
				goto out_drop_write;
			}
			test_oid =
				BTRFS_I(test->d_inode)->root->root_key.objectid;
			ret = btrfs_find_root_ref(snap_src->fs_info->tree_root,
				  path, test_oid, parent_oid);
			if (ret == 0) {
				printk("Snapshot creation failed, looping\n");
				error = -EMLINK;
				btrfs_free_path(path);
				goto out_drop_write;
			}
			btrfs_release_path(snap_src->fs_info->tree_root, path);
			test = test->d_parent;
		}
create:
		btrfs_free_path(path);
338 339 340 341 342
		error = create_snapshot(snap_src, dentry, name, namelen);
	} else {
		error = create_subvol(BTRFS_I(parent->dentry->d_inode)->root,
				      dentry, name, namelen);
	}
343 344 345 346 347 348 349 350 351 352 353 354 355 356
	if (error)
		goto out_drop_write;

	fsnotify_mkdir(parent->dentry->d_inode, dentry);
out_drop_write:
	mnt_drop_write(parent->mnt);
out_dput:
	dput(dentry);
out_unlock:
	mutex_unlock(&parent->dentry->d_inode->i_mutex);
	return error;
}


357
static int btrfs_defrag_file(struct file *file)
C
Christoph Hellwig 已提交
358 359 360 361
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
362
	struct btrfs_ordered_extent *ordered;
C
Christoph Hellwig 已提交
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
	struct page *page;
	unsigned long last_index;
	unsigned long ra_pages = root->fs_info->bdi.ra_pages;
	unsigned long total_read = 0;
	u64 page_start;
	u64 page_end;
	unsigned long i;
	int ret;

	ret = btrfs_check_free_space(root, inode->i_size, 0);
	if (ret)
		return -ENOSPC;

	mutex_lock(&inode->i_mutex);
	last_index = inode->i_size >> PAGE_CACHE_SHIFT;
	for (i = 0; i <= last_index; i++) {
		if (total_read % ra_pages == 0) {
			btrfs_force_ra(inode->i_mapping, &file->f_ra, file, i,
				       min(last_index, i + ra_pages - 1));
		}
		total_read++;
384
again:
C
Christoph Hellwig 已提交
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
		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;
			}
		}

		wait_on_page_writeback(page);

		page_start = (u64)page->index << PAGE_CACHE_SHIFT;
		page_end = page_start + PAGE_CACHE_SIZE - 1;
		lock_extent(io_tree, page_start, page_end, GFP_NOFS);
403 404 405 406 407 408 409 410 411 412 413 414

		ordered = btrfs_lookup_ordered_extent(inode, page_start);
		if (ordered) {
			unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
			unlock_page(page);
			page_cache_release(page);
			btrfs_start_ordered_extent(inode, ordered, 1);
			btrfs_put_ordered_extent(ordered);
			goto again;
		}
		set_page_extent_mapped(page);

415 416 417 418 419 420
		/*
		 * this makes sure page_mkwrite is called on the
		 * page if it is dirtied again later
		 */
		clear_page_dirty_for_io(page);

421
		btrfs_set_extent_delalloc(inode, page_start, page_end);
C
Christoph Hellwig 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452

		unlock_extent(io_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;
}

/*
 * Called inside transaction, so use GFP_NOFS
 */

static int btrfs_ioctl_resize(struct btrfs_root *root, void __user *arg)
{
	u64 new_size;
	u64 old_size;
	u64 devid = 1;
	struct btrfs_ioctl_vol_args *vol_args;
	struct btrfs_trans_handle *trans;
	struct btrfs_device *device = NULL;
	char *sizestr;
	char *devstr = NULL;
	int ret = 0;
	int namelen;
	int mod = 0;

Y
Yan Zheng 已提交
453 454 455
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

C
Christoph Hellwig 已提交
456 457 458 459 460 461 462 463 464
	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;
	}
465 466

	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
467 468
	namelen = strlen(vol_args->name);

469
	mutex_lock(&root->fs_info->volume_mutex);
C
Christoph Hellwig 已提交
470 471 472 473 474 475 476 477 478 479
	sizestr = vol_args->name;
	devstr = strchr(sizestr, ':');
	if (devstr) {
		char *end;
		sizestr = devstr + 1;
		*devstr = '\0';
		devstr = vol_args->name;
		devid = simple_strtoull(devstr, &end, 10);
		printk(KERN_INFO "resizing devid %llu\n", devid);
	}
Y
Yan Zheng 已提交
480
	device = btrfs_find_device(root, devid, NULL, NULL);
C
Christoph Hellwig 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
	if (!device) {
		printk(KERN_INFO "resizer unable to find device %llu\n", devid);
		ret = -EINVAL;
		goto out_unlock;
	}
	if (!strcmp(sizestr, "max"))
		new_size = device->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_unlock;
		}
	}

	old_size = device->total_bytes;

	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 > device->bdev->bd_inode->i_size) {
		ret = -EFBIG;
		goto out_unlock;
	}

	do_div(new_size, root->sectorsize);
	new_size *= root->sectorsize;

	printk(KERN_INFO "new size for %s is %llu\n",
		device->name, (unsigned long long)new_size);

	if (new_size > old_size) {
		trans = btrfs_start_transaction(root, 1);
		ret = btrfs_grow_device(trans, device, new_size);
		btrfs_commit_transaction(trans, root);
	} else {
		ret = btrfs_shrink_device(device, new_size);
	}

out_unlock:
539
	mutex_unlock(&root->fs_info->volume_mutex);
C
Christoph Hellwig 已提交
540 541 542 543 544
out:
	kfree(vol_args);
	return ret;
}

545
static noinline int btrfs_ioctl_snap_create(struct file *file,
546
					    void __user *arg, int subvol)
C
Christoph Hellwig 已提交
547
{
548
	struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
C
Christoph Hellwig 已提交
549 550 551
	struct btrfs_ioctl_vol_args *vol_args;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
552
	struct file *src_file;
C
Christoph Hellwig 已提交
553 554
	u64 root_dirid;
	int namelen;
555
	int ret = 0;
C
Christoph Hellwig 已提交
556

Y
Yan Zheng 已提交
557 558 559
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

C
Christoph Hellwig 已提交
560 561 562 563 564 565 566 567 568 569
	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;
	}

570
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
	namelen = strlen(vol_args->name);
	if (strchr(vol_args->name, '/')) {
		ret = -EINVAL;
		goto out;
	}

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	root_dirid = root->fs_info->sb->s_root->d_inode->i_ino,
	di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root,
			    path, root_dirid,
			    vol_args->name, namelen, 0);
	btrfs_free_path(path);

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

	if (IS_ERR(di)) {
		ret = PTR_ERR(di);
		goto out;
	}

599
	if (subvol) {
600 601
		ret = btrfs_mksubvol(&file->f_path, vol_args->name,
				     file->f_path.dentry->d_inode->i_mode,
602
				     namelen, NULL);
603
	} else {
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
		struct inode *src_inode;
		src_file = fget(vol_args->fd);
		if (!src_file) {
			ret = -EINVAL;
			goto out;
		}

		src_inode = src_file->f_path.dentry->d_inode;
		if (src_inode->i_sb != file->f_path.dentry->d_inode->i_sb) {
			printk("btrfs: Snapshot src from another FS\n");
			ret = -EINVAL;
			fput(src_file);
			goto out;
		}
		ret = btrfs_mksubvol(&file->f_path, vol_args->name,
			     file->f_path.dentry->d_inode->i_mode,
			     namelen, BTRFS_I(src_inode)->root);
		fput(src_file);
622 623
	}

C
Christoph Hellwig 已提交
624 625 626 627 628 629 630 631 632
out:
	kfree(vol_args);
	return ret;
}

static int btrfs_ioctl_defrag(struct file *file)
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
Y
Yan Zheng 已提交
633 634 635 636 637
	int ret;

	ret = mnt_want_write(file->f_path.mnt);
	if (ret)
		return ret;
C
Christoph Hellwig 已提交
638 639 640 641 642 643 644 645 646 647 648

	switch (inode->i_mode & S_IFMT) {
	case S_IFDIR:
		btrfs_defrag_root(root, 0);
		btrfs_defrag_root(root->fs_info->extent_root, 0);
		break;
	case S_IFREG:
		btrfs_defrag_file(file);
		break;
	}

649
	mnt_drop_write(file->f_path.mnt);
C
Christoph Hellwig 已提交
650 651 652
	return 0;
}

653
static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
C
Christoph Hellwig 已提交
654 655 656 657 658 659 660 661 662 663 664 665 666
{
	struct btrfs_ioctl_vol_args *vol_args;
	int ret;

	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;
	}
667
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
668 669 670 671 672 673 674
	ret = btrfs_init_new_device(root, vol_args->name);

out:
	kfree(vol_args);
	return ret;
}

675
static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
C
Christoph Hellwig 已提交
676 677 678 679
{
	struct btrfs_ioctl_vol_args *vol_args;
	int ret;

Y
Yan Zheng 已提交
680 681 682
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

C
Christoph Hellwig 已提交
683 684 685 686 687 688 689 690 691
	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;
	}
692
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
693 694 695 696 697 698 699
	ret = btrfs_rm_device(root, vol_args->name);

out:
	kfree(vol_args);
	return ret;
}

700 701
static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
		u64 off, u64 olen, u64 destoff)
C
Christoph Hellwig 已提交
702 703 704 705 706 707 708 709
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct file *src_file;
	struct inode *src;
	struct btrfs_trans_handle *trans;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
Y
Yan Zheng 已提交
710 711
	char *buf;
	struct btrfs_key key;
C
Christoph Hellwig 已提交
712 713
	u32 nritems;
	int slot;
Y
Yan Zheng 已提交
714
	int ret;
715 716 717
	u64 len = olen;
	u64 bs = root->fs_info->sb->s_blocksize;
	u64 hint_byte;
718

719 720 721 722 723 724 725 726 727 728
	/*
	 * TODO:
	 * - split compressed inline extents.  annoying: we need to
	 *   decompress into destination's address_space (the file offset
	 *   may change, so source mapping won't do), then recompress (or
	 *   otherwise reinsert) a subrange.
	 * - allow ranges within the same file to be cloned (provided
	 *   they don't overlap)?
	 */

Y
Yan Zheng 已提交
729 730 731 732
	ret = mnt_want_write(file->f_path.mnt);
	if (ret)
		return ret;

733
	src_file = fget(srcfd);
734 735 736 737
	if (!src_file) {
		ret = -EBADF;
		goto out_drop_write;
	}
C
Christoph Hellwig 已提交
738 739
	src = src_file->f_dentry->d_inode;

740 741 742 743
	ret = -EINVAL;
	if (src == inode)
		goto out_fput;

Y
Yan Zheng 已提交
744 745 746 747
	ret = -EISDIR;
	if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
		goto out_fput;

C
Christoph Hellwig 已提交
748
	ret = -EXDEV;
Y
Yan Zheng 已提交
749 750 751 752 753 754 755 756 757 758 759
	if (src->i_sb != inode->i_sb || BTRFS_I(src)->root != root)
		goto out_fput;

	ret = -ENOMEM;
	buf = vmalloc(btrfs_level_size(root, 0));
	if (!buf)
		goto out_fput;

	path = btrfs_alloc_path();
	if (!path) {
		vfree(buf);
C
Christoph Hellwig 已提交
760
		goto out_fput;
Y
Yan Zheng 已提交
761 762
	}
	path->reada = 2;
C
Christoph Hellwig 已提交
763 764 765 766 767 768 769 770 771

	if (inode < src) {
		mutex_lock(&inode->i_mutex);
		mutex_lock(&src->i_mutex);
	} else {
		mutex_lock(&src->i_mutex);
		mutex_lock(&inode->i_mutex);
	}

772 773 774
	/* determine range to clone */
	ret = -EINVAL;
	if (off >= src->i_size || off + len > src->i_size)
C
Christoph Hellwig 已提交
775
		goto out_unlock;
776 777 778 779 780 781 782 783 784 785 786 787 788 789
	if (len == 0)
		olen = len = src->i_size - off;
	/* if we extend to eof, continue to block boundary */
	if (off + len == src->i_size)
		len = ((src->i_size + bs-1) & ~(bs-1))
			- off;

	/* verify the end result is block aligned */
	if ((off & (bs-1)) ||
	    ((off + len) & (bs-1)))
		goto out_unlock;

	printk("final src extent is %llu~%llu\n", off, len);
	printk("final dst extent is %llu~%llu\n", destoff, len);
C
Christoph Hellwig 已提交
790 791 792 793

	/* do any pending delalloc/csum calc on src, one way or
	   another, and lock file content */
	while (1) {
Z
Zheng Yan 已提交
794
		struct btrfs_ordered_extent *ordered;
795 796
		lock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
		ordered = btrfs_lookup_first_ordered_extent(inode, off+len);
Y
Yan Zheng 已提交
797
		if (BTRFS_I(src)->delalloc_bytes == 0 && !ordered)
C
Christoph Hellwig 已提交
798
			break;
799
		unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
Y
Yan Zheng 已提交
800 801
		if (ordered)
			btrfs_put_ordered_extent(ordered);
802
		btrfs_wait_ordered_range(src, off, off+len);
C
Christoph Hellwig 已提交
803 804
	}

Y
Yan Zheng 已提交
805 806 807
	trans = btrfs_start_transaction(root, 1);
	BUG_ON(!trans);

808 809 810 811
	/* punch hole in destination first */
	btrfs_drop_extents(trans, root, inode, off, off+len, 0, &hint_byte);

	/* clone data */
C
Christoph Hellwig 已提交
812
	key.objectid = src->i_ino;
Y
Yan Zheng 已提交
813 814
	key.type = BTRFS_EXTENT_DATA_KEY;
	key.offset = 0;
C
Christoph Hellwig 已提交
815 816 817 818 819 820 821 822 823 824

	while (1) {
		/*
		 * note the key will change type as we walk through the
		 * tree.
		 */
		ret = btrfs_search_slot(trans, root, &key, path, 0, 0);
		if (ret < 0)
			goto out;

Y
Yan Zheng 已提交
825 826
		nritems = btrfs_header_nritems(path->nodes[0]);
		if (path->slots[0] >= nritems) {
C
Christoph Hellwig 已提交
827 828 829 830 831
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto out;
			if (ret > 0)
				break;
Y
Yan Zheng 已提交
832
			nritems = btrfs_header_nritems(path->nodes[0]);
C
Christoph Hellwig 已提交
833 834 835 836
		}
		leaf = path->nodes[0];
		slot = path->slots[0];

Y
Yan Zheng 已提交
837
		btrfs_item_key_to_cpu(leaf, &key, slot);
838
		if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
C
Christoph Hellwig 已提交
839 840 841
		    key.objectid != src->i_ino)
			break;

842 843 844
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
			struct btrfs_file_extent_item *extent;
			int type;
Z
Zheng Yan 已提交
845 846
			u32 size;
			struct btrfs_key new_key;
847 848 849
			u64 disko = 0, diskl = 0;
			u64 datao = 0, datal = 0;
			u8 comp;
Z
Zheng Yan 已提交
850 851 852 853 854

			size = btrfs_item_size_nr(leaf, slot);
			read_extent_buffer(leaf, buf,
					   btrfs_item_ptr_offset(leaf, slot),
					   size);
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869

			extent = btrfs_item_ptr(leaf, slot,
						struct btrfs_file_extent_item);
			comp = btrfs_file_extent_compression(leaf, extent);
			type = btrfs_file_extent_type(leaf, extent);
			if (type == BTRFS_FILE_EXTENT_REG) {
				disko = btrfs_file_extent_disk_bytenr(leaf, extent);
				diskl = btrfs_file_extent_disk_num_bytes(leaf, extent);
				datao = btrfs_file_extent_offset(leaf, extent);
				datal = btrfs_file_extent_num_bytes(leaf, extent);
			} else if (type == BTRFS_FILE_EXTENT_INLINE) {
				/* take upper bound, may be compressed */
				datal = btrfs_file_extent_ram_bytes(leaf,
								    extent);
			}
Z
Zheng Yan 已提交
870 871
			btrfs_release_path(root, path);

872 873 874 875
			if (key.offset + datal < off ||
			    key.offset >= off+len)
				goto next;

Z
Zheng Yan 已提交
876 877
			memcpy(&new_key, &key, sizeof(new_key));
			new_key.objectid = inode->i_ino;
878
			new_key.offset = key.offset + destoff - off;
Z
Zheng Yan 已提交
879

880 881 882 883 884 885 886 887 888
			if (type == BTRFS_FILE_EXTENT_REG) {
				ret = btrfs_insert_empty_item(trans, root, path,
							      &new_key, size);
				if (ret)
					goto out;

				leaf = path->nodes[0];
				slot = path->slots[0];
				write_extent_buffer(leaf, buf,
Z
Zheng Yan 已提交
889 890
					    btrfs_item_ptr_offset(leaf, slot),
					    size);
Y
Yan Zheng 已提交
891

892
				extent = btrfs_item_ptr(leaf, slot,
C
Christoph Hellwig 已提交
893
						struct btrfs_file_extent_item);
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
				printk("  orig disk %llu~%llu data %llu~%llu\n",
				       disko, diskl, datao, datal);

				if (off > key.offset) {
					datao += off - key.offset;
					datal -= off - key.offset;
				}
				if (key.offset + datao + datal + key.offset >
				    off + len)
					datal = off + len - key.offset - datao;
				/* disko == 0 means it's a hole */
				if (!disko)
					datao = 0;
				printk(" final disk %llu~%llu data %llu~%llu\n",
				       disko, diskl, datao, datal);

				btrfs_set_file_extent_offset(leaf, extent,
							     datao);
				btrfs_set_file_extent_num_bytes(leaf, extent,
								datal);
				if (disko) {
					inode_add_bytes(inode, datal);
Y
Yan Zheng 已提交
916
					ret = btrfs_inc_extent_ref(trans, root,
917 918 919 920
						   disko, diskl, leaf->start,
						   root->root_key.objectid,
						   trans->transid,
						   inode->i_ino);
Z
Zheng Yan 已提交
921
					BUG_ON(ret);
C
Christoph Hellwig 已提交
922
				}
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
			} else if (type == BTRFS_FILE_EXTENT_INLINE) {
				u64 skip = 0;
				u64 trim = 0;
				if (off > key.offset) {
					skip = off - key.offset;
					new_key.offset += skip;
				}
				if (key.offset + datal > off+len)
					trim = key.offset + datal - (off+len);
				printk("len %lld skip %lld trim %lld\n",
				       datal, skip, trim);
				if (comp && (skip || trim)) {
					printk("btrfs clone_range can't split compressed inline extents yet\n");
					ret = -EINVAL;
					goto out;
				}
				size -= skip + trim;
				datal -= skip + trim;
				ret = btrfs_insert_empty_item(trans, root, path,
							      &new_key, size);
				if (ret)
					goto out;

				if (skip) {
					u32 start = btrfs_file_extent_calc_inline_size(0);
					memmove(buf+start, buf+start+skip,
						datal);
				}

				leaf = path->nodes[0];
				slot = path->slots[0];
				write_extent_buffer(leaf, buf,
					    btrfs_item_ptr_offset(leaf, slot),
					    size);
				inode_add_bytes(inode, datal);
C
Christoph Hellwig 已提交
958
			}
959 960

			btrfs_mark_buffer_dirty(leaf);
Y
Yan Zheng 已提交
961
		}
962 963

	next:
Z
Zheng Yan 已提交
964
		btrfs_release_path(root, path);
C
Christoph Hellwig 已提交
965 966 967 968
		key.offset++;
	}
	ret = 0;
out:
Y
Yan Zheng 已提交
969 970 971
	btrfs_release_path(root, path);
	if (ret == 0) {
		inode->i_mtime = inode->i_ctime = CURRENT_TIME;
972 973
		if (destoff + olen > inode->i_size)
			btrfs_i_size_write(inode, destoff + olen);
Y
Yan Zheng 已提交
974 975 976
		BTRFS_I(inode)->flags = BTRFS_I(src)->flags;
		ret = btrfs_update_inode(trans, root, inode);
	}
C
Christoph Hellwig 已提交
977
	btrfs_end_transaction(trans, root);
978
	unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
Y
Yan Zheng 已提交
979 980
	if (ret)
		vmtruncate(inode, 0);
C
Christoph Hellwig 已提交
981 982 983
out_unlock:
	mutex_unlock(&src->i_mutex);
	mutex_unlock(&inode->i_mutex);
Y
Yan Zheng 已提交
984 985
	vfree(buf);
	btrfs_free_path(path);
C
Christoph Hellwig 已提交
986 987
out_fput:
	fput(src_file);
988 989
out_drop_write:
	mnt_drop_write(file->f_path.mnt);
C
Christoph Hellwig 已提交
990 991 992
	return ret;
}

993
static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
994 995 996
{
	struct btrfs_ioctl_clone_range_args args;

997
	if (copy_from_user(&args, argp, sizeof(args)))
998 999 1000 1001 1002
		return -EFAULT;
	return btrfs_ioctl_clone(file, args.src_fd, args.src_offset,
				 args.src_length, args.dest_offset);
}

C
Christoph Hellwig 已提交
1003 1004 1005 1006 1007 1008
/*
 * there are many ways the trans_start and trans_end ioctls can lead
 * to deadlocks.  They should only be used by applications that
 * basically own the machine, and have a very in depth understanding
 * of all the possible deadlocks and enospc problems.
 */
1009
static long btrfs_ioctl_trans_start(struct file *file)
C
Christoph Hellwig 已提交
1010 1011 1012 1013 1014 1015
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;

1016 1017 1018
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

C
Christoph Hellwig 已提交
1019 1020 1021 1022
	if (file->private_data) {
		ret = -EINPROGRESS;
		goto out;
	}
1023

Y
Yan Zheng 已提交
1024 1025 1026 1027
	ret = mnt_want_write(file->f_path.mnt);
	if (ret)
		goto out;

1028 1029 1030 1031 1032
	mutex_lock(&root->fs_info->trans_mutex);
	root->fs_info->open_ioctl_trans++;
	mutex_unlock(&root->fs_info->trans_mutex);

	trans = btrfs_start_ioctl_transaction(root, 0);
C
Christoph Hellwig 已提交
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
	if (trans)
		file->private_data = trans;
	else
		ret = -ENOMEM;
	/*printk(KERN_INFO "btrfs_ioctl_trans_start on %p\n", file);*/
out:
	return ret;
}

/*
 * there are many ways the trans_start and trans_end ioctls can lead
 * to deadlocks.  They should only be used by applications that
 * basically own the machine, and have a very in depth understanding
 * of all the possible deadlocks and enospc problems.
 */
long btrfs_ioctl_trans_end(struct file *file)
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	int ret = 0;

	trans = file->private_data;
	if (!trans) {
		ret = -EINVAL;
		goto out;
	}
	btrfs_end_transaction(trans, root);
C
Christoph Hellwig 已提交
1061
	file->private_data = NULL;
1062 1063 1064 1065 1066

	mutex_lock(&root->fs_info->trans_mutex);
	root->fs_info->open_ioctl_trans--;
	mutex_unlock(&root->fs_info->trans_mutex);

1067 1068
	mnt_drop_write(file->f_path.mnt);

C
Christoph Hellwig 已提交
1069 1070 1071 1072 1073 1074 1075 1076
out:
	return ret;
}

long btrfs_ioctl(struct file *file, unsigned int
		cmd, unsigned long arg)
{
	struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
1077
	void __user *argp = (void __user *)arg;
C
Christoph Hellwig 已提交
1078 1079 1080

	switch (cmd) {
	case BTRFS_IOC_SNAP_CREATE:
1081
		return btrfs_ioctl_snap_create(file, argp, 0);
1082
	case BTRFS_IOC_SUBVOL_CREATE:
1083
		return btrfs_ioctl_snap_create(file, argp, 1);
C
Christoph Hellwig 已提交
1084 1085 1086
	case BTRFS_IOC_DEFRAG:
		return btrfs_ioctl_defrag(file);
	case BTRFS_IOC_RESIZE:
1087
		return btrfs_ioctl_resize(root, argp);
C
Christoph Hellwig 已提交
1088
	case BTRFS_IOC_ADD_DEV:
1089
		return btrfs_ioctl_add_dev(root, argp);
C
Christoph Hellwig 已提交
1090
	case BTRFS_IOC_RM_DEV:
1091
		return btrfs_ioctl_rm_dev(root, argp);
C
Christoph Hellwig 已提交
1092 1093 1094
	case BTRFS_IOC_BALANCE:
		return btrfs_balance(root->fs_info->dev_root);
	case BTRFS_IOC_CLONE:
1095 1096
		return btrfs_ioctl_clone(file, arg, 0, 0, 0);
	case BTRFS_IOC_CLONE_RANGE:
1097
		return btrfs_ioctl_clone_range(file, argp);
C
Christoph Hellwig 已提交
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
	case BTRFS_IOC_TRANS_START:
		return btrfs_ioctl_trans_start(file);
	case BTRFS_IOC_TRANS_END:
		return btrfs_ioctl_trans_end(file);
	case BTRFS_IOC_SYNC:
		btrfs_sync_fs(file->f_dentry->d_sb, 1);
		return 0;
	}

	return -ENOTTY;
}