ioctl.c 80.0 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
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/backing-dev.h>
31
#include <linux/mount.h>
C
Christoph Hellwig 已提交
32
#include <linux/mpage.h>
33
#include <linux/namei.h>
C
Christoph Hellwig 已提交
34 35 36 37 38
#include <linux/swap.h>
#include <linux/writeback.h>
#include <linux/statfs.h>
#include <linux/compat.h>
#include <linux/bit_spinlock.h>
39
#include <linux/security.h>
C
Christoph Hellwig 已提交
40
#include <linux/xattr.h>
41
#include <linux/vmalloc.h>
42
#include <linux/slab.h>
43
#include <linux/blkdev.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"
53
#include "inode-map.h"
54
#include "backref.h"
C
Christoph Hellwig 已提交
55

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
/* Mask out flags that are inappropriate for the given type of inode. */
static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
{
	if (S_ISDIR(mode))
		return flags;
	else if (S_ISREG(mode))
		return flags & ~FS_DIRSYNC_FL;
	else
		return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
}

/*
 * Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl.
 */
static unsigned int btrfs_flags_to_ioctl(unsigned int flags)
{
	unsigned int iflags = 0;

	if (flags & BTRFS_INODE_SYNC)
		iflags |= FS_SYNC_FL;
	if (flags & BTRFS_INODE_IMMUTABLE)
		iflags |= FS_IMMUTABLE_FL;
	if (flags & BTRFS_INODE_APPEND)
		iflags |= FS_APPEND_FL;
	if (flags & BTRFS_INODE_NODUMP)
		iflags |= FS_NODUMP_FL;
	if (flags & BTRFS_INODE_NOATIME)
		iflags |= FS_NOATIME_FL;
	if (flags & BTRFS_INODE_DIRSYNC)
		iflags |= FS_DIRSYNC_FL;
L
Li Zefan 已提交
86 87 88 89 90 91 92
	if (flags & BTRFS_INODE_NODATACOW)
		iflags |= FS_NOCOW_FL;

	if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS))
		iflags |= FS_COMPR_FL;
	else if (flags & BTRFS_INODE_NOCOMPRESS)
		iflags |= FS_NOCOMP_FL;
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

	return iflags;
}

/*
 * Update inode->i_flags based on the btrfs internal flags.
 */
void btrfs_update_iflags(struct inode *inode)
{
	struct btrfs_inode *ip = BTRFS_I(inode);

	inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);

	if (ip->flags & BTRFS_INODE_SYNC)
		inode->i_flags |= S_SYNC;
	if (ip->flags & BTRFS_INODE_IMMUTABLE)
		inode->i_flags |= S_IMMUTABLE;
	if (ip->flags & BTRFS_INODE_APPEND)
		inode->i_flags |= S_APPEND;
	if (ip->flags & BTRFS_INODE_NOATIME)
		inode->i_flags |= S_NOATIME;
	if (ip->flags & BTRFS_INODE_DIRSYNC)
		inode->i_flags |= S_DIRSYNC;
}

/*
 * Inherit flags from the parent inode.
 *
121
 * Currently only the compression flags and the cow flags are inherited.
122 123 124
 */
void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
{
125 126 127 128 129 130
	unsigned int flags;

	if (!dir)
		return;

	flags = BTRFS_I(dir)->flags;
131

132 133 134 135 136 137 138 139 140 141
	if (flags & BTRFS_INODE_NOCOMPRESS) {
		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
	} else if (flags & BTRFS_INODE_COMPRESS) {
		BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
		BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
	}

	if (flags & BTRFS_INODE_NODATACOW)
		BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
142 143 144 145 146 147 148 149 150 151 152 153 154 155

	btrfs_update_iflags(inode);
}

static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
{
	struct btrfs_inode *ip = BTRFS_I(file->f_path.dentry->d_inode);
	unsigned int flags = btrfs_flags_to_ioctl(ip->flags);

	if (copy_to_user(arg, &flags, sizeof(flags)))
		return -EFAULT;
	return 0;
}

156 157 158 159 160
static int check_flags(unsigned int flags)
{
	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
		      FS_NOATIME_FL | FS_NODUMP_FL | \
		      FS_SYNC_FL | FS_DIRSYNC_FL | \
L
Li Zefan 已提交
161 162
		      FS_NOCOMP_FL | FS_COMPR_FL |
		      FS_NOCOW_FL))
163 164 165 166 167 168 169 170
		return -EOPNOTSUPP;

	if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
		return -EINVAL;

	return 0;
}

171 172 173 174 175 176 177 178
static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	struct btrfs_inode *ip = BTRFS_I(inode);
	struct btrfs_root *root = ip->root;
	struct btrfs_trans_handle *trans;
	unsigned int flags, oldflags;
	int ret;
179 180
	u64 ip_oldflags;
	unsigned int i_oldflags;
181

L
Li Zefan 已提交
182 183 184
	if (btrfs_root_readonly(root))
		return -EROFS;

185 186 187
	if (copy_from_user(&flags, arg, sizeof(flags)))
		return -EFAULT;

188 189 190
	ret = check_flags(flags);
	if (ret)
		return ret;
C
Christoph Hellwig 已提交
191

192
	if (!inode_owner_or_capable(inode))
193 194 195 196
		return -EACCES;

	mutex_lock(&inode->i_mutex);

197 198 199
	ip_oldflags = ip->flags;
	i_oldflags = inode->i_flags;

200 201 202 203 204 205 206 207 208
	flags = btrfs_mask_flags(inode->i_mode, flags);
	oldflags = btrfs_flags_to_ioctl(ip->flags);
	if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
		if (!capable(CAP_LINUX_IMMUTABLE)) {
			ret = -EPERM;
			goto out_unlock;
		}
	}

209
	ret = mnt_want_write_file(file);
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
	if (ret)
		goto out_unlock;

	if (flags & FS_SYNC_FL)
		ip->flags |= BTRFS_INODE_SYNC;
	else
		ip->flags &= ~BTRFS_INODE_SYNC;
	if (flags & FS_IMMUTABLE_FL)
		ip->flags |= BTRFS_INODE_IMMUTABLE;
	else
		ip->flags &= ~BTRFS_INODE_IMMUTABLE;
	if (flags & FS_APPEND_FL)
		ip->flags |= BTRFS_INODE_APPEND;
	else
		ip->flags &= ~BTRFS_INODE_APPEND;
	if (flags & FS_NODUMP_FL)
		ip->flags |= BTRFS_INODE_NODUMP;
	else
		ip->flags &= ~BTRFS_INODE_NODUMP;
	if (flags & FS_NOATIME_FL)
		ip->flags |= BTRFS_INODE_NOATIME;
	else
		ip->flags &= ~BTRFS_INODE_NOATIME;
	if (flags & FS_DIRSYNC_FL)
		ip->flags |= BTRFS_INODE_DIRSYNC;
	else
		ip->flags &= ~BTRFS_INODE_DIRSYNC;
L
Li Zefan 已提交
237 238 239 240
	if (flags & FS_NOCOW_FL)
		ip->flags |= BTRFS_INODE_NODATACOW;
	else
		ip->flags &= ~BTRFS_INODE_NODATACOW;
241

242 243 244 245 246 247 248 249 250 251 252
	/*
	 * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
	 * flag may be changed automatically if compression code won't make
	 * things smaller.
	 */
	if (flags & FS_NOCOMP_FL) {
		ip->flags &= ~BTRFS_INODE_COMPRESS;
		ip->flags |= BTRFS_INODE_NOCOMPRESS;
	} else if (flags & FS_COMPR_FL) {
		ip->flags |= BTRFS_INODE_COMPRESS;
		ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
L
Li Zefan 已提交
253 254
	} else {
		ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
255
	}
256

257
	trans = btrfs_start_transaction(root, 1);
258 259 260 261
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto out_drop;
	}
262

263 264
	btrfs_update_iflags(inode);
	inode->i_ctime = CURRENT_TIME;
265 266 267
	ret = btrfs_update_inode(trans, root, inode);

	btrfs_end_transaction(trans, root);
268 269 270 271 272
 out_drop:
	if (ret) {
		ip->flags = ip_oldflags;
		inode->i_flags = i_oldflags;
	}
273

A
Al Viro 已提交
274
	mnt_drop_write_file(file);
275 276
 out_unlock:
	mutex_unlock(&inode->i_mutex);
277
	return ret;
278 279 280 281 282 283 284 285
}

static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
{
	struct inode *inode = file->f_path.dentry->d_inode;

	return put_user(inode->i_generation, arg);
}
C
Christoph Hellwig 已提交
286

287 288
static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
{
289
	struct btrfs_fs_info *fs_info = btrfs_sb(fdentry(file)->d_sb);
290 291 292 293 294
	struct btrfs_device *device;
	struct request_queue *q;
	struct fstrim_range range;
	u64 minlen = ULLONG_MAX;
	u64 num_devices = 0;
295
	u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
296 297 298 299 300
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

301 302 303
	rcu_read_lock();
	list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
				dev_list) {
304 305 306 307 308 309 310 311 312
		if (!device->bdev)
			continue;
		q = bdev_get_queue(device->bdev);
		if (blk_queue_discard(q)) {
			num_devices++;
			minlen = min((u64)q->limits.discard_granularity,
				     minlen);
		}
	}
313
	rcu_read_unlock();
314

315 316 317 318
	if (!num_devices)
		return -EOPNOTSUPP;
	if (copy_from_user(&range, arg, sizeof(range)))
		return -EFAULT;
319 320
	if (range.start > total_bytes)
		return -EINVAL;
321

322
	range.len = min(range.len, total_bytes - range.start);
323
	range.minlen = max(range.minlen, minlen);
324
	ret = btrfs_trim_fs(fs_info->tree_root, &range);
325 326 327 328 329 330 331 332 333
	if (ret < 0)
		return ret;

	if (copy_to_user(arg, &range, sizeof(range)))
		return -EFAULT;

	return 0;
}

334 335
static noinline int create_subvol(struct btrfs_root *root,
				  struct dentry *dentry,
S
Sage Weil 已提交
336 337
				  char *name, int namelen,
				  u64 *async_transid)
C
Christoph Hellwig 已提交
338 339 340 341 342 343
{
	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;
344
	struct btrfs_root *new_root;
345
	struct dentry *parent = dentry->d_parent;
346
	struct inode *dir;
C
Christoph Hellwig 已提交
347 348 349 350
	int ret;
	int err;
	u64 objectid;
	u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
351
	u64 index = 0;
C
Christoph Hellwig 已提交
352

353
	ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
354
	if (ret)
355
		return ret;
356 357 358

	dir = parent->d_inode;

J
Josef Bacik 已提交
359 360 361 362 363 364
	/*
	 * 1 - inode item
	 * 2 - refs
	 * 1 - root item
	 * 2 - dir items
	 */
365
	trans = btrfs_start_transaction(root, 6);
366
	if (IS_ERR(trans))
367
		return PTR_ERR(trans);
C
Christoph Hellwig 已提交
368

369
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
A
Arne Jansen 已提交
370
				      0, objectid, NULL, 0, 0, 0, 0);
371 372 373 374
	if (IS_ERR(leaf)) {
		ret = PTR_ERR(leaf);
		goto fail;
	}
C
Christoph Hellwig 已提交
375

376
	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
C
Christoph Hellwig 已提交
377 378
	btrfs_set_header_bytenr(leaf, leaf->start);
	btrfs_set_header_generation(leaf, trans->transid);
379
	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
C
Christoph Hellwig 已提交
380 381 382 383 384
	btrfs_set_header_owner(leaf, objectid);

	write_extent_buffer(leaf, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(leaf),
			    BTRFS_FSID_SIZE);
385 386 387
	write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
			    (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
			    BTRFS_UUID_SIZE);
C
Christoph Hellwig 已提交
388 389 390 391 392 393 394
	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);
395
	inode_item->nbytes = cpu_to_le64(root->leafsize);
C
Christoph Hellwig 已提交
396 397
	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);

398 399 400 401
	root_item.flags = 0;
	root_item.byte_limit = 0;
	inode_item->flags = cpu_to_le64(BTRFS_INODE_ROOT_ITEM_INIT);

C
Christoph Hellwig 已提交
402
	btrfs_set_root_bytenr(&root_item, leaf->start);
403
	btrfs_set_root_generation(&root_item, trans->transid);
C
Christoph Hellwig 已提交
404 405
	btrfs_set_root_level(&root_item, 0);
	btrfs_set_root_refs(&root_item, 1);
406
	btrfs_set_root_used(&root_item, leaf->len);
Y
Yan Zheng 已提交
407
	btrfs_set_root_last_snapshot(&root_item, 0);
C
Christoph Hellwig 已提交
408 409 410 411

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

412
	btrfs_tree_unlock(leaf);
C
Christoph Hellwig 已提交
413 414 415 416 417 418
	free_extent_buffer(leaf);
	leaf = NULL;

	btrfs_set_root_dirid(&root_item, new_dirid);

	key.objectid = objectid;
419
	key.offset = 0;
C
Christoph Hellwig 已提交
420 421 422 423 424 425
	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;

426 427
	key.offset = (u64)-1;
	new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
428 429 430 431 432
	if (IS_ERR(new_root)) {
		btrfs_abort_transaction(trans, root, PTR_ERR(new_root));
		ret = PTR_ERR(new_root);
		goto fail;
	}
433 434 435

	btrfs_record_root_in_trans(trans, new_root);

436
	ret = btrfs_create_subvol_root(trans, new_root, new_dirid);
437 438
	if (ret) {
		/* We potentially lose an unused inode item here */
439
		btrfs_abort_transaction(trans, root, ret);
440 441 442
		goto fail;
	}

C
Christoph Hellwig 已提交
443 444 445
	/*
	 * insert the directory item
	 */
446
	ret = btrfs_set_inode_index(dir, &index);
447 448 449 450
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
451 452

	ret = btrfs_insert_dir_item(trans, root,
453
				    name, namelen, dir, &key,
454
				    BTRFS_FT_DIR, index);
455 456
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
C
Christoph Hellwig 已提交
457
		goto fail;
458
	}
459

460 461 462 463
	btrfs_i_size_write(dir, dir->i_size + namelen * 2);
	ret = btrfs_update_inode(trans, root, dir);
	BUG_ON(ret);

464
	ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
465
				 objectid, root->root_key.objectid,
L
Li Zefan 已提交
466
				 btrfs_ino(dir), index, name, namelen);
467

468
	BUG_ON(ret);
C
Christoph Hellwig 已提交
469

470
	d_instantiate(dentry, btrfs_lookup_dentry(dir, dentry));
C
Christoph Hellwig 已提交
471
fail:
S
Sage Weil 已提交
472 473 474 475 476 477
	if (async_transid) {
		*async_transid = trans->transid;
		err = btrfs_commit_transaction_async(trans, root, 1);
	} else {
		err = btrfs_commit_transaction(trans, root);
	}
C
Christoph Hellwig 已提交
478 479 480 481 482
	if (err && !ret)
		ret = err;
	return ret;
}

S
Sage Weil 已提交
483
static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
L
Li Zefan 已提交
484 485
			   char *name, int namelen, u64 *async_transid,
			   bool readonly)
C
Christoph Hellwig 已提交
486
{
487
	struct inode *inode;
C
Christoph Hellwig 已提交
488 489
	struct btrfs_pending_snapshot *pending_snapshot;
	struct btrfs_trans_handle *trans;
490
	int ret;
C
Christoph Hellwig 已提交
491 492 493 494

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

495
	pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
496 497 498 499
	if (!pending_snapshot)
		return -ENOMEM;

	btrfs_init_block_rsv(&pending_snapshot->block_rsv);
500
	pending_snapshot->dentry = dentry;
C
Christoph Hellwig 已提交
501
	pending_snapshot->root = root;
L
Li Zefan 已提交
502
	pending_snapshot->readonly = readonly;
503 504 505 506 507 508 509 510 511 512

	trans = btrfs_start_transaction(root->fs_info->extent_root, 5);
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto fail;
	}

	ret = btrfs_snap_reserve_metadata(trans, pending_snapshot);
	BUG_ON(ret);

513
	spin_lock(&root->fs_info->trans_lock);
C
Christoph Hellwig 已提交
514 515
	list_add(&pending_snapshot->list,
		 &trans->transaction->pending_snapshots);
516
	spin_unlock(&root->fs_info->trans_lock);
S
Sage Weil 已提交
517 518 519 520 521 522 523 524
	if (async_transid) {
		*async_transid = trans->transid;
		ret = btrfs_commit_transaction_async(trans,
				     root->fs_info->extent_root, 1);
	} else {
		ret = btrfs_commit_transaction(trans,
					       root->fs_info->extent_root);
	}
525
	BUG_ON(ret);
526 527 528 529 530

	ret = pending_snapshot->error;
	if (ret)
		goto fail;

531 532 533
	ret = btrfs_orphan_cleanup(pending_snapshot->snap);
	if (ret)
		goto fail;
C
Christoph Hellwig 已提交
534

535
	inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
536 537 538 539 540 541 542 543
	if (IS_ERR(inode)) {
		ret = PTR_ERR(inode);
		goto fail;
	}
	BUG_ON(!inode);
	d_instantiate(dentry, inode);
	ret = 0;
fail:
544
	kfree(pending_snapshot);
C
Christoph Hellwig 已提交
545 546 547
	return ret;
}

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 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 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
/*  copy of check_sticky in fs/namei.c()
* It's inline, so penalty for filesystems that don't use sticky bit is
* minimal.
*/
static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
{
	uid_t fsuid = current_fsuid();

	if (!(dir->i_mode & S_ISVTX))
		return 0;
	if (inode->i_uid == fsuid)
		return 0;
	if (dir->i_uid == fsuid)
		return 0;
	return !capable(CAP_FOWNER);
}

/*  copy of may_delete in fs/namei.c()
 *	Check whether we can remove a link victim from directory dir, check
 *  whether the type of victim is right.
 *  1. We can't do it if dir is read-only (done in permission())
 *  2. We should have write and exec permissions on dir
 *  3. We can't remove anything from append-only dir
 *  4. We can't do anything with immutable dir (done in permission())
 *  5. If the sticky bit on dir is set we should either
 *	a. be owner of dir, or
 *	b. be owner of victim, or
 *	c. have CAP_FOWNER capability
 *  6. If the victim is append-only or immutable we can't do antyhing with
 *     links pointing to it.
 *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
 *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
 *  9. We can't remove a root or mountpoint.
 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
 *     nfs_async_unlink().
 */

static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir)
{
	int error;

	if (!victim->d_inode)
		return -ENOENT;

	BUG_ON(victim->d_parent->d_inode != dir);
	audit_inode_child(victim, dir);

	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
	if (error)
		return error;
	if (IS_APPEND(dir))
		return -EPERM;
	if (btrfs_check_sticky(dir, victim->d_inode)||
		IS_APPEND(victim->d_inode)||
	    IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
		return -EPERM;
	if (isdir) {
		if (!S_ISDIR(victim->d_inode->i_mode))
			return -ENOTDIR;
		if (IS_ROOT(victim))
			return -EBUSY;
	} else if (S_ISDIR(victim->d_inode->i_mode))
		return -EISDIR;
	if (IS_DEADDIR(dir))
		return -ENOENT;
	if (victim->d_flags & DCACHE_NFSFS_RENAMED)
		return -EBUSY;
	return 0;
}

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
/* 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.
 */
633 634
static noinline int btrfs_mksubvol(struct path *parent,
				   char *name, int namelen,
S
Sage Weil 已提交
635
				   struct btrfs_root *snap_src,
L
Li Zefan 已提交
636
				   u64 *async_transid, bool readonly)
637
{
638
	struct inode *dir  = parent->dentry->d_inode;
639 640 641
	struct dentry *dentry;
	int error;

642
	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
643 644 645 646 647 648 649 650 651 652 653 654 655 656

	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;

	error = mnt_want_write(parent->mnt);
	if (error)
		goto out_dput;

657
	error = btrfs_may_create(dir, dentry);
658 659 660
	if (error)
		goto out_drop_write;

661 662 663 664 665
	down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);

	if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
		goto out_up_read;

666
	if (snap_src) {
S
Sage Weil 已提交
667
		error = create_snapshot(snap_src, dentry,
L
Li Zefan 已提交
668
					name, namelen, async_transid, readonly);
669
	} else {
670
		error = create_subvol(BTRFS_I(dir)->root, dentry,
S
Sage Weil 已提交
671
				      name, namelen, async_transid);
672
	}
673 674 675 676
	if (!error)
		fsnotify_mkdir(dir, dentry);
out_up_read:
	up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
677 678 679 680 681
out_drop_write:
	mnt_drop_write(parent->mnt);
out_dput:
	dput(dentry);
out_unlock:
682
	mutex_unlock(&dir->i_mutex);
683 684 685
	return error;
}

C
Chris Mason 已提交
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
/*
 * When we're defragging a range, we don't want to kick it off again
 * if it is really just waiting for delalloc to send it down.
 * If we find a nice big extent or delalloc range for the bytes in the
 * file you want to defrag, we return 0 to let you know to skip this
 * part of the file
 */
static int check_defrag_in_cache(struct inode *inode, u64 offset, int thresh)
{
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	u64 end;

	read_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
	read_unlock(&em_tree->lock);

	if (em) {
		end = extent_map_end(em);
		free_extent_map(em);
		if (end - offset > thresh)
			return 0;
	}
	/* if we already have a nice delalloc here, just stop */
	thresh /= 2;
	end = count_range_bits(io_tree, &offset, offset + thresh,
			       thresh, EXTENT_DELALLOC, 1);
	if (end >= thresh)
		return 0;
	return 1;
}

/*
 * helper function to walk through a file and find extents
 * newer than a specific transid, and smaller than thresh.
 *
 * This is used by the defragging code to find new and small
 * extents
 */
static int find_new_extents(struct btrfs_root *root,
			    struct inode *inode, u64 newer_than,
			    u64 *off, int thresh)
{
	struct btrfs_path *path;
	struct btrfs_key min_key;
	struct btrfs_key max_key;
	struct extent_buffer *leaf;
	struct btrfs_file_extent_item *extent;
	int type;
	int ret;
737
	u64 ino = btrfs_ino(inode);
C
Chris Mason 已提交
738 739 740 741 742

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

743
	min_key.objectid = ino;
C
Chris Mason 已提交
744 745 746
	min_key.type = BTRFS_EXTENT_DATA_KEY;
	min_key.offset = *off;

747
	max_key.objectid = ino;
C
Chris Mason 已提交
748 749 750 751 752 753 754 755 756 757
	max_key.type = (u8)-1;
	max_key.offset = (u64)-1;

	path->keep_locks = 1;

	while(1) {
		ret = btrfs_search_forward(root, &min_key, &max_key,
					   path, 0, newer_than);
		if (ret != 0)
			goto none;
758
		if (min_key.objectid != ino)
C
Chris Mason 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
			goto none;
		if (min_key.type != BTRFS_EXTENT_DATA_KEY)
			goto none;

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

		type = btrfs_file_extent_type(leaf, extent);
		if (type == BTRFS_FILE_EXTENT_REG &&
		    btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
		    check_defrag_in_cache(inode, min_key.offset, thresh)) {
			*off = min_key.offset;
			btrfs_free_path(path);
			return 0;
		}

		if (min_key.offset == (u64)-1)
			goto none;

		min_key.offset++;
		btrfs_release_path(path);
	}
none:
	btrfs_free_path(path);
	return -ENOENT;
}

787
static int should_defrag_range(struct inode *inode, u64 start, u64 len,
C
Chris Mason 已提交
788 789
			       int thresh, u64 *last_len, u64 *skip,
			       u64 *defrag_end)
790 791 792 793 794 795 796
{
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_map *em = NULL;
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	int ret = 1;

	/*
797
	 * make sure that once we start defragging an extent, we keep on
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
	 * defragging it
	 */
	if (start < *defrag_end)
		return 1;

	*skip = 0;

	/*
	 * hopefully we have this extent in the tree already, try without
	 * the full extent lock
	 */
	read_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
	read_unlock(&em_tree->lock);

	if (!em) {
		/* get the big lock and read metadata off disk */
815
		lock_extent(io_tree, start, start + len - 1);
816
		em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
817
		unlock_extent(io_tree, start, start + len - 1);
818

819
		if (IS_ERR(em))
820 821 822 823 824 825 826 827 828 829
			return 0;
	}

	/* this will cover holes, and inline extents */
	if (em->block_start >= EXTENT_MAP_LAST_BYTE)
		ret = 0;

	/*
	 * we hit a real extent, if it is big don't bother defragging it again
	 */
C
Chris Mason 已提交
830
	if ((*last_len == 0 || *last_len >= thresh) && em->len >= thresh)
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852
		ret = 0;

	/*
	 * last_len ends up being a counter of how many bytes we've defragged.
	 * every time we choose not to defrag an extent, we reset *last_len
	 * so that the next tiny extent will force a defrag.
	 *
	 * The end result of this is that tiny extents before a single big
	 * extent will force at least part of that big extent to be defragged.
	 */
	if (ret) {
		*defrag_end = extent_map_end(em);
	} else {
		*last_len = 0;
		*skip = extent_map_end(em);
		*defrag_end = 0;
	}

	free_extent_map(em);
	return ret;
}

C
Chris Mason 已提交
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
/*
 * it doesn't do much good to defrag one or two pages
 * at a time.  This pulls in a nice chunk of pages
 * to COW and defrag.
 *
 * It also makes sure the delalloc code has enough
 * dirty data to avoid making new small extents as part
 * of the defrag
 *
 * It's a good idea to start RA on this range
 * before calling this.
 */
static int cluster_pages_for_defrag(struct inode *inode,
				    struct page **pages,
				    unsigned long start_index,
				    int num_pages)
C
Christoph Hellwig 已提交
869
{
C
Chris Mason 已提交
870 871 872 873 874 875 876
	unsigned long file_end;
	u64 isize = i_size_read(inode);
	u64 page_start;
	u64 page_end;
	int ret;
	int i;
	int i_done;
877
	struct btrfs_ordered_extent *ordered;
C
Chris Mason 已提交
878
	struct extent_state *cached_state = NULL;
879
	struct extent_io_tree *tree;
880
	gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
C
Chris Mason 已提交
881 882 883 884 885 886 887 888 889 890

	if (isize == 0)
		return 0;
	file_end = (isize - 1) >> PAGE_CACHE_SHIFT;

	ret = btrfs_delalloc_reserve_space(inode,
					   num_pages << PAGE_CACHE_SHIFT);
	if (ret)
		return ret;
	i_done = 0;
891
	tree = &BTRFS_I(inode)->io_tree;
C
Chris Mason 已提交
892 893 894 895

	/* step one, lock all the pages */
	for (i = 0; i < num_pages; i++) {
		struct page *page;
896
again:
897
		page = find_or_create_page(inode->i_mapping,
898
					   start_index + i, mask);
C
Chris Mason 已提交
899 900 901
		if (!page)
			break;

902 903 904
		page_start = page_offset(page);
		page_end = page_start + PAGE_CACHE_SIZE - 1;
		while (1) {
905
			lock_extent(tree, page_start, page_end);
906 907
			ordered = btrfs_lookup_ordered_extent(inode,
							      page_start);
908
			unlock_extent(tree, page_start, page_end);
909 910 911 912 913 914 915 916 917
			if (!ordered)
				break;

			unlock_page(page);
			btrfs_start_ordered_extent(inode, ordered, 1);
			btrfs_put_ordered_extent(ordered);
			lock_page(page);
		}

C
Chris Mason 已提交
918 919 920 921 922 923 924 925 926 927
		if (!PageUptodate(page)) {
			btrfs_readpage(NULL, page);
			lock_page(page);
			if (!PageUptodate(page)) {
				unlock_page(page);
				page_cache_release(page);
				ret = -EIO;
				break;
			}
		}
928

C
Chris Mason 已提交
929 930
		isize = i_size_read(inode);
		file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
931
		if (!isize || page->index > file_end) {
C
Chris Mason 已提交
932 933 934 935 936
			/* whoops, we blew past eof, skip this page */
			unlock_page(page);
			page_cache_release(page);
			break;
		}
937 938 939 940 941 942 943

		if (page->mapping != inode->i_mapping) {
			unlock_page(page);
			page_cache_release(page);
			goto again;
		}

C
Chris Mason 已提交
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
		pages[i] = page;
		i_done++;
	}
	if (!i_done || ret)
		goto out;

	if (!(inode->i_sb->s_flags & MS_ACTIVE))
		goto out;

	/*
	 * so now we have a nice long stream of locked
	 * and up to date pages, lets wait on them
	 */
	for (i = 0; i < i_done; i++)
		wait_on_page_writeback(pages[i]);

	page_start = page_offset(pages[0]);
	page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;

	lock_extent_bits(&BTRFS_I(inode)->io_tree,
964
			 page_start, page_end - 1, 0, &cached_state);
C
Chris Mason 已提交
965 966 967 968 969 970
	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
			  page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
			  EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
			  GFP_NOFS);

	if (i_done != num_pages) {
971 972 973
		spin_lock(&BTRFS_I(inode)->lock);
		BTRFS_I(inode)->outstanding_extents++;
		spin_unlock(&BTRFS_I(inode)->lock);
C
Chris Mason 已提交
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
		btrfs_delalloc_release_space(inode,
				     (num_pages - i_done) << PAGE_CACHE_SHIFT);
	}


	btrfs_set_extent_delalloc(inode, page_start, page_end - 1,
				  &cached_state);

	unlock_extent_cached(&BTRFS_I(inode)->io_tree,
			     page_start, page_end - 1, &cached_state,
			     GFP_NOFS);

	for (i = 0; i < i_done; i++) {
		clear_page_dirty_for_io(pages[i]);
		ClearPageChecked(pages[i]);
		set_page_extent_mapped(pages[i]);
		set_page_dirty(pages[i]);
		unlock_page(pages[i]);
		page_cache_release(pages[i]);
	}
	return i_done;
out:
	for (i = 0; i < i_done; i++) {
		unlock_page(pages[i]);
		page_cache_release(pages[i]);
	}
	btrfs_delalloc_release_space(inode, num_pages << PAGE_CACHE_SHIFT);
	return ret;

}

int btrfs_defrag_file(struct inode *inode, struct file *file,
		      struct btrfs_ioctl_defrag_range_args *range,
		      u64 newer_than, unsigned long max_to_defrag)
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
1010
	struct btrfs_super_block *disk_super;
C
Chris Mason 已提交
1011
	struct file_ra_state *ra = NULL;
C
Christoph Hellwig 已提交
1012
	unsigned long last_index;
1013
	u64 isize = i_size_read(inode);
1014
	u64 features;
1015 1016 1017
	u64 last_len = 0;
	u64 skip = 0;
	u64 defrag_end = 0;
C
Chris Mason 已提交
1018
	u64 newer_off = range->start;
C
Christoph Hellwig 已提交
1019
	unsigned long i;
1020
	unsigned long ra_index = 0;
C
Christoph Hellwig 已提交
1021
	int ret;
C
Chris Mason 已提交
1022
	int defrag_count = 0;
1023
	int compress_type = BTRFS_COMPRESS_ZLIB;
C
Chris Mason 已提交
1024
	int extent_thresh = range->extent_thresh;
1025 1026
	int max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT;
	int cluster = max_cluster;
C
Chris Mason 已提交
1027 1028 1029 1030 1031
	u64 new_align = ~((u64)128 * 1024 - 1);
	struct page **pages = NULL;

	if (extent_thresh == 0)
		extent_thresh = 256 * 1024;
1032 1033 1034 1035 1036 1037 1038

	if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
		if (range->compress_type > BTRFS_COMPRESS_TYPES)
			return -EINVAL;
		if (range->compress_type)
			compress_type = range->compress_type;
	}
C
Christoph Hellwig 已提交
1039

1040
	if (isize == 0)
1041 1042
		return 0;

C
Chris Mason 已提交
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
	/*
	 * if we were not given a file, allocate a readahead
	 * context
	 */
	if (!file) {
		ra = kzalloc(sizeof(*ra), GFP_NOFS);
		if (!ra)
			return -ENOMEM;
		file_ra_state_init(ra, inode->i_mapping);
	} else {
		ra = &file->f_ra;
	}

1056
	pages = kmalloc(sizeof(struct page *) * max_cluster,
C
Chris Mason 已提交
1057 1058 1059 1060 1061 1062 1063
			GFP_NOFS);
	if (!pages) {
		ret = -ENOMEM;
		goto out_ra;
	}

	/* find the last page to defrag */
C
Chris Mason 已提交
1064
	if (range->start + range->len > range->start) {
1065
		last_index = min_t(u64, isize - 1,
C
Chris Mason 已提交
1066 1067
			 range->start + range->len - 1) >> PAGE_CACHE_SHIFT;
	} else {
1068
		last_index = (isize - 1) >> PAGE_CACHE_SHIFT;
C
Chris Mason 已提交
1069 1070
	}

C
Chris Mason 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
	if (newer_than) {
		ret = find_new_extents(root, inode, newer_than,
				       &newer_off, 64 * 1024);
		if (!ret) {
			range->start = newer_off;
			/*
			 * we always align our defrag to help keep
			 * the extents in the file evenly spaced
			 */
			i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
		} else
			goto out_ra;
	} else {
		i = range->start >> PAGE_CACHE_SHIFT;
	}
	if (!max_to_defrag)
L
Liu Bo 已提交
1087
		max_to_defrag = last_index + 1;
C
Chris Mason 已提交
1088

L
Li Zefan 已提交
1089 1090 1091 1092 1093 1094 1095
	/*
	 * make writeback starts from i, so the defrag range can be
	 * written sequentially.
	 */
	if (i < inode->i_mapping->writeback_index)
		inode->i_mapping->writeback_index = i;

1096 1097 1098
	while (i <= last_index && defrag_count < max_to_defrag &&
	       (i < (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
		PAGE_CACHE_SHIFT)) {
C
Chris Mason 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107
		/*
		 * make sure we stop running if someone unmounts
		 * the FS
		 */
		if (!(inode->i_sb->s_flags & MS_ACTIVE))
			break;

		if (!newer_than &&
		    !should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
C
Chris Mason 已提交
1108
					PAGE_CACHE_SIZE,
C
Chris Mason 已提交
1109
					extent_thresh,
C
Chris Mason 已提交
1110
					&last_len, &skip,
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
					&defrag_end)) {
			unsigned long next;
			/*
			 * the should_defrag function tells us how much to skip
			 * bump our counter by the suggested amount
			 */
			next = (skip + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
			i = max(i + 1, next);
			continue;
		}
1121 1122 1123 1124 1125 1126 1127 1128 1129

		if (!newer_than) {
			cluster = (PAGE_CACHE_ALIGN(defrag_end) >>
				   PAGE_CACHE_SHIFT) - i;
			cluster = min(cluster, max_cluster);
		} else {
			cluster = max_cluster;
		}

C
Chris Mason 已提交
1130
		if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
1131
			BTRFS_I(inode)->force_compress = compress_type;
1132

1133 1134 1135 1136 1137 1138
		if (i + cluster > ra_index) {
			ra_index = max(i, ra_index);
			btrfs_force_ra(inode->i_mapping, ra, file, ra_index,
				       cluster);
			ra_index += max_cluster;
		}
1139

1140
		ret = cluster_pages_for_defrag(inode, pages, i, cluster);
C
Chris Mason 已提交
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
		if (ret < 0)
			goto out_ra;

		defrag_count += ret;
		balance_dirty_pages_ratelimited_nr(inode->i_mapping, ret);

		if (newer_than) {
			if (newer_off == (u64)-1)
				break;

			newer_off = max(newer_off + 1,
					(u64)i << PAGE_CACHE_SHIFT);

			ret = find_new_extents(root, inode,
					       newer_than, &newer_off,
					       64 * 1024);
			if (!ret) {
				range->start = newer_off;
				i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
			} else {
				break;
C
Christoph Hellwig 已提交
1162
			}
C
Chris Mason 已提交
1163
		} else {
1164
			if (ret > 0) {
L
Li Zefan 已提交
1165
				i += ret;
1166 1167
				last_len += ret << PAGE_CACHE_SHIFT;
			} else {
L
Li Zefan 已提交
1168
				i++;
1169 1170
				last_len = 0;
			}
C
Christoph Hellwig 已提交
1171 1172 1173
		}
	}

C
Chris Mason 已提交
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
	if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO))
		filemap_flush(inode->i_mapping);

	if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
		/* the filemap_flush will queue IO into the worker threads, but
		 * we have to make sure the IO is actually started and that
		 * ordered extents get created before we return
		 */
		atomic_inc(&root->fs_info->async_submit_draining);
		while (atomic_read(&root->fs_info->nr_async_submits) ||
		      atomic_read(&root->fs_info->async_delalloc_pages)) {
			wait_event(root->fs_info->async_submit_wait,
			   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
			    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
		}
		atomic_dec(&root->fs_info->async_submit_draining);

		mutex_lock(&inode->i_mutex);
1192
		BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
C
Chris Mason 已提交
1193 1194 1195
		mutex_unlock(&inode->i_mutex);
	}

1196
	disk_super = root->fs_info->super_copy;
1197 1198 1199 1200 1201 1202
	features = btrfs_super_incompat_flags(disk_super);
	if (range->compress_type == BTRFS_COMPRESS_LZO) {
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
		btrfs_set_super_incompat_flags(disk_super, features);
	}

1203
	ret = defrag_count;
1204

C
Chris Mason 已提交
1205 1206 1207 1208
out_ra:
	if (!file)
		kfree(ra);
	kfree(pages);
1209
	return ret;
C
Christoph Hellwig 已提交
1210 1211
}

1212 1213
static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
					void __user *arg)
C
Christoph Hellwig 已提交
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
{
	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 mod = 0;

Y
Yan Zheng 已提交
1226 1227 1228
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

1229 1230 1231
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

1232 1233 1234 1235 1236 1237 1238
	mutex_lock(&root->fs_info->volume_mutex);
	if (root->fs_info->balance_ctl) {
		printk(KERN_INFO "btrfs: balance in progress\n");
		ret = -EINVAL;
		goto out;
	}

L
Li Zefan 已提交
1239
	vol_args = memdup_user(arg, sizeof(*vol_args));
1240 1241 1242 1243
	if (IS_ERR(vol_args)) {
		ret = PTR_ERR(vol_args);
		goto out;
	}
1244 1245

	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
1246 1247 1248 1249 1250 1251 1252 1253 1254

	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);
1255
		printk(KERN_INFO "btrfs: resizing devid %llu\n",
1256
		       (unsigned long long)devid);
C
Christoph Hellwig 已提交
1257
	}
Y
Yan Zheng 已提交
1258
	device = btrfs_find_device(root, devid, NULL, NULL);
C
Christoph Hellwig 已提交
1259
	if (!device) {
1260
		printk(KERN_INFO "btrfs: resizer unable to find device %llu\n",
1261
		       (unsigned long long)devid);
C
Christoph Hellwig 已提交
1262
		ret = -EINVAL;
1263
		goto out_free;
C
Christoph Hellwig 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
	}
	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++;
		}
A
Akinobu Mita 已提交
1275
		new_size = memparse(sizestr, NULL);
C
Christoph Hellwig 已提交
1276 1277
		if (new_size == 0) {
			ret = -EINVAL;
1278
			goto out_free;
C
Christoph Hellwig 已提交
1279 1280 1281 1282 1283 1284 1285 1286
		}
	}

	old_size = device->total_bytes;

	if (mod < 0) {
		if (new_size > old_size) {
			ret = -EINVAL;
1287
			goto out_free;
C
Christoph Hellwig 已提交
1288 1289 1290 1291 1292 1293 1294 1295
		}
		new_size = old_size - new_size;
	} else if (mod > 0) {
		new_size = old_size + new_size;
	}

	if (new_size < 256 * 1024 * 1024) {
		ret = -EINVAL;
1296
		goto out_free;
C
Christoph Hellwig 已提交
1297 1298 1299
	}
	if (new_size > device->bdev->bd_inode->i_size) {
		ret = -EFBIG;
1300
		goto out_free;
C
Christoph Hellwig 已提交
1301 1302 1303 1304 1305
	}

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

1306
	printk(KERN_INFO "btrfs: new size for %s is %llu\n",
C
Christoph Hellwig 已提交
1307 1308 1309
		device->name, (unsigned long long)new_size);

	if (new_size > old_size) {
1310
		trans = btrfs_start_transaction(root, 0);
1311 1312
		if (IS_ERR(trans)) {
			ret = PTR_ERR(trans);
1313
			goto out_free;
1314
		}
C
Christoph Hellwig 已提交
1315 1316
		ret = btrfs_grow_device(trans, device, new_size);
		btrfs_commit_transaction(trans, root);
1317
	} else if (new_size < old_size) {
C
Christoph Hellwig 已提交
1318 1319 1320
		ret = btrfs_shrink_device(device, new_size);
	}

1321
out_free:
C
Christoph Hellwig 已提交
1322
	kfree(vol_args);
1323 1324
out:
	mutex_unlock(&root->fs_info->volume_mutex);
C
Christoph Hellwig 已提交
1325 1326 1327
	return ret;
}

S
Sage Weil 已提交
1328 1329 1330 1331
static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
						    char *name,
						    unsigned long fd,
						    int subvol,
L
Li Zefan 已提交
1332 1333
						    u64 *transid,
						    bool readonly)
C
Christoph Hellwig 已提交
1334
{
1335
	struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
1336
	struct file *src_file;
C
Christoph Hellwig 已提交
1337
	int namelen;
1338
	int ret = 0;
C
Christoph Hellwig 已提交
1339

Y
Yan Zheng 已提交
1340 1341 1342
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

S
Sage Weil 已提交
1343 1344
	namelen = strlen(name);
	if (strchr(name, '/')) {
C
Christoph Hellwig 已提交
1345 1346 1347 1348
		ret = -EINVAL;
		goto out;
	}

1349 1350 1351 1352 1353 1354
	if (name[0] == '.' &&
	   (namelen == 1 || (name[1] == '.' && namelen == 2))) {
		ret = -EEXIST;
		goto out;
	}

1355
	if (subvol) {
S
Sage Weil 已提交
1356
		ret = btrfs_mksubvol(&file->f_path, name, namelen,
L
Li Zefan 已提交
1357
				     NULL, transid, readonly);
1358
	} else {
1359
		struct inode *src_inode;
S
Sage Weil 已提交
1360
		src_file = fget(fd);
1361 1362 1363 1364 1365 1366 1367
		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) {
C
Chris Mason 已提交
1368 1369
			printk(KERN_INFO "btrfs: Snapshot src from "
			       "another FS\n");
1370 1371 1372 1373
			ret = -EINVAL;
			fput(src_file);
			goto out;
		}
S
Sage Weil 已提交
1374 1375
		ret = btrfs_mksubvol(&file->f_path, name, namelen,
				     BTRFS_I(src_inode)->root,
L
Li Zefan 已提交
1376
				     transid, readonly);
1377
		fput(src_file);
1378
	}
C
Christoph Hellwig 已提交
1379
out:
S
Sage Weil 已提交
1380 1381 1382 1383
	return ret;
}

static noinline int btrfs_ioctl_snap_create(struct file *file,
1384
					    void __user *arg, int subvol)
S
Sage Weil 已提交
1385
{
1386
	struct btrfs_ioctl_vol_args *vol_args;
S
Sage Weil 已提交
1387 1388
	int ret;

1389 1390 1391 1392
	vol_args = memdup_user(arg, sizeof(*vol_args));
	if (IS_ERR(vol_args))
		return PTR_ERR(vol_args);
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
S
Sage Weil 已提交
1393

1394
	ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
L
Li Zefan 已提交
1395 1396
					      vol_args->fd, subvol,
					      NULL, false);
1397

1398 1399 1400
	kfree(vol_args);
	return ret;
}
1401

1402 1403 1404 1405 1406 1407 1408
static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
					       void __user *arg, int subvol)
{
	struct btrfs_ioctl_vol_args_v2 *vol_args;
	int ret;
	u64 transid = 0;
	u64 *ptr = NULL;
L
Li Zefan 已提交
1409
	bool readonly = false;
1410

1411 1412 1413 1414
	vol_args = memdup_user(arg, sizeof(*vol_args));
	if (IS_ERR(vol_args))
		return PTR_ERR(vol_args);
	vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
1415

L
Li Zefan 已提交
1416 1417 1418
	if (vol_args->flags &
	    ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY)) {
		ret = -EOPNOTSUPP;
1419
		goto out;
S
Sage Weil 已提交
1420
	}
1421 1422 1423

	if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC)
		ptr = &transid;
L
Li Zefan 已提交
1424 1425
	if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
		readonly = true;
1426 1427

	ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
L
Li Zefan 已提交
1428 1429
					      vol_args->fd, subvol,
					      ptr, readonly);
1430 1431 1432 1433 1434 1435

	if (ret == 0 && ptr &&
	    copy_to_user(arg +
			 offsetof(struct btrfs_ioctl_vol_args_v2,
				  transid), ptr, sizeof(*ptr)))
		ret = -EFAULT;
1436
out:
C
Christoph Hellwig 已提交
1437 1438 1439 1440
	kfree(vol_args);
	return ret;
}

1441 1442 1443 1444 1445 1446 1447 1448
static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
						void __user *arg)
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	int ret = 0;
	u64 flags = 0;

L
Li Zefan 已提交
1449
	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
		return -EINVAL;

	down_read(&root->fs_info->subvol_sem);
	if (btrfs_root_readonly(root))
		flags |= BTRFS_SUBVOL_RDONLY;
	up_read(&root->fs_info->subvol_sem);

	if (copy_to_user(arg, &flags, sizeof(flags)))
		ret = -EFAULT;

	return ret;
}

static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
					      void __user *arg)
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
	u64 root_flags;
	u64 flags;
	int ret = 0;

	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

L
Li Zefan 已提交
1476
	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
1477 1478 1479 1480 1481
		return -EINVAL;

	if (copy_from_user(&flags, arg, sizeof(flags)))
		return -EFAULT;

1482
	if (flags & BTRFS_SUBVOL_CREATE_ASYNC)
1483 1484 1485 1486 1487
		return -EINVAL;

	if (flags & ~BTRFS_SUBVOL_RDONLY)
		return -EOPNOTSUPP;

1488
	if (!inode_owner_or_capable(inode))
1489 1490
		return -EACCES;

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
	down_write(&root->fs_info->subvol_sem);

	/* nothing to do */
	if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
		goto out;

	root_flags = btrfs_root_flags(&root->root_item);
	if (flags & BTRFS_SUBVOL_RDONLY)
		btrfs_set_root_flags(&root->root_item,
				     root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
	else
		btrfs_set_root_flags(&root->root_item,
				     root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);

	trans = btrfs_start_transaction(root, 1);
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto out_reset;
	}

1511
	ret = btrfs_update_root(trans, root->fs_info->tree_root,
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
				&root->root_key, &root->root_item);

	btrfs_commit_transaction(trans, root);
out_reset:
	if (ret)
		btrfs_set_root_flags(&root->root_item, root_flags);
out:
	up_write(&root->fs_info->subvol_sem);
	return ret;
}

1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
/*
 * helper to check if the subvolume references other subvolumes
 */
static noinline int may_destroy_subvol(struct btrfs_root *root)
{
	struct btrfs_path *path;
	struct btrfs_key key;
	int ret;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = root->root_key.objectid;
	key.type = BTRFS_ROOT_REF_KEY;
	key.offset = (u64)-1;

	ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
				&key, path, 0, 0);
	if (ret < 0)
		goto out;
	BUG_ON(ret == 0);

	ret = 0;
	if (path->slots[0] > 0) {
		path->slots[0]--;
		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
		if (key.objectid == root->root_key.objectid &&
		    key.type == BTRFS_ROOT_REF_KEY)
			ret = -ENOTEMPTY;
	}
out:
	btrfs_free_path(path);
	return ret;
}

1559 1560 1561
static noinline int key_in_sk(struct btrfs_key *key,
			      struct btrfs_ioctl_search_key *sk)
{
1562 1563 1564 1565 1566 1567 1568 1569 1570
	struct btrfs_key test;
	int ret;

	test.objectid = sk->min_objectid;
	test.type = sk->min_type;
	test.offset = sk->min_offset;

	ret = btrfs_comp_cpu_keys(key, &test);
	if (ret < 0)
1571
		return 0;
1572 1573 1574 1575 1576 1577 1578

	test.objectid = sk->max_objectid;
	test.type = sk->max_type;
	test.offset = sk->max_offset;

	ret = btrfs_comp_cpu_keys(key, &test);
	if (ret > 0)
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
		return 0;
	return 1;
}

static noinline int copy_to_sk(struct btrfs_root *root,
			       struct btrfs_path *path,
			       struct btrfs_key *key,
			       struct btrfs_ioctl_search_key *sk,
			       char *buf,
			       unsigned long *sk_offset,
			       int *num_found)
{
	u64 found_transid;
	struct extent_buffer *leaf;
	struct btrfs_ioctl_search_header sh;
	unsigned long item_off;
	unsigned long item_len;
	int nritems;
	int i;
	int slot;
	int ret = 0;

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

	if (btrfs_header_generation(leaf) > sk->max_transid) {
		i = nritems;
		goto advance_key;
	}
	found_transid = btrfs_header_generation(leaf);

	for (i = slot; i < nritems; i++) {
		item_off = btrfs_item_ptr_offset(leaf, i);
		item_len = btrfs_item_size_nr(leaf, i);

		if (item_len > BTRFS_SEARCH_ARGS_BUFSIZE)
			item_len = 0;

		if (sizeof(sh) + item_len + *sk_offset >
		    BTRFS_SEARCH_ARGS_BUFSIZE) {
			ret = 1;
			goto overflow;
		}

		btrfs_item_key_to_cpu(leaf, key, i);
		if (!key_in_sk(key, sk))
			continue;

		sh.objectid = key->objectid;
		sh.offset = key->offset;
		sh.type = key->type;
		sh.len = item_len;
		sh.transid = found_transid;

		/* copy search result header */
		memcpy(buf + *sk_offset, &sh, sizeof(sh));
		*sk_offset += sizeof(sh);

		if (item_len) {
			char *p = buf + *sk_offset;
			/* copy the item */
			read_extent_buffer(leaf, p,
					   item_off, item_len);
			*sk_offset += item_len;
		}
1645
		(*num_found)++;
1646 1647 1648 1649 1650

		if (*num_found >= sk->nr_items)
			break;
	}
advance_key:
1651 1652
	ret = 0;
	if (key->offset < (u64)-1 && key->offset < sk->max_offset)
1653
		key->offset++;
1654 1655
	else if (key->type < (u8)-1 && key->type < sk->max_type) {
		key->offset = 0;
1656
		key->type++;
1657 1658 1659
	} else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) {
		key->offset = 0;
		key->type = 0;
1660
		key->objectid++;
1661 1662
	} else
		ret = 1;
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
overflow:
	return ret;
}

static noinline int search_ioctl(struct inode *inode,
				 struct btrfs_ioctl_search_args *args)
{
	struct btrfs_root *root;
	struct btrfs_key key;
	struct btrfs_key max_key;
	struct btrfs_path *path;
	struct btrfs_ioctl_search_key *sk = &args->key;
	struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info;
	int ret;
	int num_found = 0;
	unsigned long sk_offset = 0;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	if (sk->tree_id == 0) {
		/* search the root of the inode that was passed */
		root = BTRFS_I(inode)->root;
	} else {
		key.objectid = sk->tree_id;
		key.type = BTRFS_ROOT_ITEM_KEY;
		key.offset = (u64)-1;
		root = btrfs_read_fs_root_no_name(info, &key);
		if (IS_ERR(root)) {
			printk(KERN_ERR "could not find root %llu\n",
			       sk->tree_id);
			btrfs_free_path(path);
			return -ENOENT;
		}
	}

	key.objectid = sk->min_objectid;
	key.type = sk->min_type;
	key.offset = sk->min_offset;

	max_key.objectid = sk->max_objectid;
	max_key.type = sk->max_type;
	max_key.offset = sk->max_offset;

	path->keep_locks = 1;

	while(1) {
		ret = btrfs_search_forward(root, &key, &max_key, path, 0,
					   sk->min_transid);
		if (ret != 0) {
			if (ret > 0)
				ret = 0;
			goto err;
		}
		ret = copy_to_sk(root, path, &key, sk, args->buf,
				 &sk_offset, &num_found);
1720
		btrfs_release_path(path);
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
		if (ret || num_found >= sk->nr_items)
			break;

	}
	ret = 0;
err:
	sk->nr_items = num_found;
	btrfs_free_path(path);
	return ret;
}

static noinline int btrfs_ioctl_tree_search(struct file *file,
					   void __user *argp)
{
	 struct btrfs_ioctl_search_args *args;
	 struct inode *inode;
	 int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

J
Julia Lawall 已提交
1742 1743 1744
	args = memdup_user(argp, sizeof(*args));
	if (IS_ERR(args))
		return PTR_ERR(args);
1745 1746 1747 1748 1749 1750 1751 1752 1753

	inode = fdentry(file)->d_inode;
	ret = search_ioctl(inode, args);
	if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
		ret = -EFAULT;
	kfree(args);
	return ret;
}

1754
/*
1755 1756 1757
 * Search INODE_REFs to identify path name of 'dirid' directory
 * in a 'tree_id' tree. and sets path name to 'name'.
 */
1758 1759 1760 1761 1762
static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
				u64 tree_id, u64 dirid, char *name)
{
	struct btrfs_root *root;
	struct btrfs_key key;
1763
	char *ptr;
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
	int ret = -1;
	int slot;
	int len;
	int total_len = 0;
	struct btrfs_inode_ref *iref;
	struct extent_buffer *l;
	struct btrfs_path *path;

	if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
		name[0]='\0';
		return 0;
	}

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

1781
	ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX];
1782 1783 1784 1785 1786 1787 1788

	key.objectid = tree_id;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = (u64)-1;
	root = btrfs_read_fs_root_no_name(info, &key);
	if (IS_ERR(root)) {
		printk(KERN_ERR "could not find root %llu\n", tree_id);
1789 1790
		ret = -ENOENT;
		goto out;
1791 1792 1793 1794
	}

	key.objectid = dirid;
	key.type = BTRFS_INODE_REF_KEY;
1795
	key.offset = (u64)-1;
1796 1797 1798 1799 1800 1801 1802 1803

	while(1) {
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		if (ret < 0)
			goto out;

		l = path->nodes[0];
		slot = path->slots[0];
1804 1805
		if (ret > 0 && slot > 0)
			slot--;
1806 1807 1808
		btrfs_item_key_to_cpu(l, &key, slot);

		if (ret > 0 && (key.objectid != dirid ||
1809 1810
				key.type != BTRFS_INODE_REF_KEY)) {
			ret = -ENOENT;
1811
			goto out;
1812
		}
1813 1814 1815 1816 1817

		iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
		len = btrfs_inode_ref_name_len(l, iref);
		ptr -= len + 1;
		total_len += len + 1;
1818
		if (ptr < name)
1819 1820 1821 1822 1823 1824 1825 1826
			goto out;

		*(ptr + len) = '/';
		read_extent_buffer(l, ptr,(unsigned long)(iref + 1), len);

		if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
			break;

1827
		btrfs_release_path(path);
1828
		key.objectid = key.offset;
1829
		key.offset = (u64)-1;
1830 1831
		dirid = key.objectid;
	}
1832
	if (ptr < name)
1833
		goto out;
1834
	memmove(name, ptr, total_len);
1835 1836 1837 1838
	name[total_len]='\0';
	ret = 0;
out:
	btrfs_free_path(path);
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	return ret;
}

static noinline int btrfs_ioctl_ino_lookup(struct file *file,
					   void __user *argp)
{
	 struct btrfs_ioctl_ino_lookup_args *args;
	 struct inode *inode;
	 int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

J
Julia Lawall 已提交
1852 1853 1854
	args = memdup_user(argp, sizeof(*args));
	if (IS_ERR(args))
		return PTR_ERR(args);
1855

1856 1857
	inode = fdentry(file)->d_inode;

1858 1859 1860
	if (args->treeid == 0)
		args->treeid = BTRFS_I(inode)->root->root_key.objectid;

1861 1862 1863 1864 1865 1866 1867 1868
	ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
					args->treeid, args->objectid,
					args->name);

	if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
		ret = -EFAULT;

	kfree(args);
1869 1870 1871
	return ret;
}

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
static noinline int btrfs_ioctl_snap_destroy(struct file *file,
					     void __user *arg)
{
	struct dentry *parent = fdentry(file);
	struct dentry *dentry;
	struct inode *dir = parent->d_inode;
	struct inode *inode;
	struct btrfs_root *root = BTRFS_I(dir)->root;
	struct btrfs_root *dest = NULL;
	struct btrfs_ioctl_vol_args *vol_args;
	struct btrfs_trans_handle *trans;
	int namelen;
	int ret;
	int err = 0;

	vol_args = memdup_user(arg, sizeof(*vol_args));
	if (IS_ERR(vol_args))
		return PTR_ERR(vol_args);

	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
	namelen = strlen(vol_args->name);
	if (strchr(vol_args->name, '/') ||
	    strncmp(vol_args->name, "..", namelen) == 0) {
		err = -EINVAL;
		goto out;
	}

1899
	err = mnt_want_write_file(file);
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
	if (err)
		goto out;

	mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
	dentry = lookup_one_len(vol_args->name, parent, namelen);
	if (IS_ERR(dentry)) {
		err = PTR_ERR(dentry);
		goto out_unlock_dir;
	}

	if (!dentry->d_inode) {
		err = -ENOENT;
		goto out_dput;
	}

	inode = dentry->d_inode;
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
	dest = BTRFS_I(inode)->root;
	if (!capable(CAP_SYS_ADMIN)){
		/*
		 * Regular user.  Only allow this with a special mount
		 * option, when the user has write+exec access to the
		 * subvol root, and when rmdir(2) would have been
		 * allowed.
		 *
		 * Note that this is _not_ check that the subvol is
		 * empty or doesn't contain data that we wouldn't
		 * otherwise be able to delete.
		 *
		 * Users who want to delete empty subvols should try
		 * rmdir(2).
		 */
		err = -EPERM;
		if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
			goto out_dput;

		/*
		 * Do not allow deletion if the parent dir is the same
		 * as the dir to be deleted.  That means the ioctl
		 * must be called on the dentry referencing the root
		 * of the subvol, not a random directory contained
		 * within it.
		 */
		err = -EINVAL;
		if (root == dest)
			goto out_dput;

		err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
		if (err)
			goto out_dput;

		/* check if subvolume may be deleted by a non-root user */
		err = btrfs_may_delete(dir, dentry, 1);
		if (err)
			goto out_dput;
	}

L
Li Zefan 已提交
1956
	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
		err = -EINVAL;
		goto out_dput;
	}

	mutex_lock(&inode->i_mutex);
	err = d_invalidate(dentry);
	if (err)
		goto out_unlock;

	down_write(&root->fs_info->subvol_sem);

	err = may_destroy_subvol(dest);
	if (err)
		goto out_up_write;

1972 1973 1974
	trans = btrfs_start_transaction(root, 0);
	if (IS_ERR(trans)) {
		err = PTR_ERR(trans);
1975
		goto out_up_write;
1976 1977 1978
	}
	trans->block_rsv = &root->fs_info->global_block_rsv;

1979 1980 1981 1982
	ret = btrfs_unlink_subvol(trans, root, dir,
				dest->root_key.objectid,
				dentry->d_name.name,
				dentry->d_name.len);
1983 1984 1985 1986 1987
	if (ret) {
		err = ret;
		btrfs_abort_transaction(trans, root, ret);
		goto out_end_trans;
	}
1988 1989 1990 1991 1992 1993 1994 1995

	btrfs_record_root_in_trans(trans, dest);

	memset(&dest->root_item.drop_progress, 0,
		sizeof(dest->root_item.drop_progress));
	dest->root_item.drop_level = 0;
	btrfs_set_root_refs(&dest->root_item, 0);

1996 1997 1998 1999
	if (!xchg(&dest->orphan_item_inserted, 1)) {
		ret = btrfs_insert_orphan_item(trans,
					root->fs_info->tree_root,
					dest->root_key.objectid);
2000 2001 2002 2003 2004
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
			err = ret;
			goto out_end_trans;
		}
2005
	}
2006
out_end_trans:
S
Sage Weil 已提交
2007
	ret = btrfs_end_transaction(trans, root);
2008 2009
	if (ret && !err)
		err = ret;
2010 2011 2012 2013 2014 2015
	inode->i_flags |= S_DEAD;
out_up_write:
	up_write(&root->fs_info->subvol_sem);
out_unlock:
	mutex_unlock(&inode->i_mutex);
	if (!err) {
2016
		shrink_dcache_sb(root->fs_info->sb);
2017 2018 2019 2020 2021 2022 2023
		btrfs_invalidate_inodes(dest);
		d_delete(dentry);
	}
out_dput:
	dput(dentry);
out_unlock_dir:
	mutex_unlock(&dir->i_mutex);
A
Al Viro 已提交
2024
	mnt_drop_write_file(file);
2025 2026 2027 2028 2029
out:
	kfree(vol_args);
	return err;
}

C
Chris Mason 已提交
2030
static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
C
Christoph Hellwig 已提交
2031 2032 2033
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2034
	struct btrfs_ioctl_defrag_range_args *range;
Y
Yan Zheng 已提交
2035 2036
	int ret;

L
Li Zefan 已提交
2037 2038 2039
	if (btrfs_root_readonly(root))
		return -EROFS;

2040
	ret = mnt_want_write_file(file);
Y
Yan Zheng 已提交
2041 2042
	if (ret)
		return ret;
C
Christoph Hellwig 已提交
2043 2044 2045

	switch (inode->i_mode & S_IFMT) {
	case S_IFDIR:
2046 2047 2048 2049
		if (!capable(CAP_SYS_ADMIN)) {
			ret = -EPERM;
			goto out;
		}
2050 2051 2052 2053
		ret = btrfs_defrag_root(root, 0);
		if (ret)
			goto out;
		ret = btrfs_defrag_root(root->fs_info->extent_root, 0);
C
Christoph Hellwig 已提交
2054 2055
		break;
	case S_IFREG:
2056 2057 2058 2059
		if (!(file->f_mode & FMODE_WRITE)) {
			ret = -EINVAL;
			goto out;
		}
C
Chris Mason 已提交
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071

		range = kzalloc(sizeof(*range), GFP_KERNEL);
		if (!range) {
			ret = -ENOMEM;
			goto out;
		}

		if (argp) {
			if (copy_from_user(range, argp,
					   sizeof(*range))) {
				ret = -EFAULT;
				kfree(range);
2072
				goto out;
C
Chris Mason 已提交
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
			}
			/* compression requires us to start the IO */
			if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
				range->flags |= BTRFS_DEFRAG_RANGE_START_IO;
				range->extent_thresh = (u32)-1;
			}
		} else {
			/* the rest are all set to zero by kzalloc */
			range->len = (u64)-1;
		}
C
Chris Mason 已提交
2083 2084 2085 2086
		ret = btrfs_defrag_file(fdentry(file)->d_inode, file,
					range, 0, 0);
		if (ret > 0)
			ret = 0;
C
Chris Mason 已提交
2087
		kfree(range);
C
Christoph Hellwig 已提交
2088
		break;
2089 2090
	default:
		ret = -EINVAL;
C
Christoph Hellwig 已提交
2091
	}
2092
out:
A
Al Viro 已提交
2093
	mnt_drop_write_file(file);
2094
	return ret;
C
Christoph Hellwig 已提交
2095 2096
}

2097
static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
C
Christoph Hellwig 已提交
2098 2099 2100 2101
{
	struct btrfs_ioctl_vol_args *vol_args;
	int ret;

2102 2103 2104
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

2105 2106 2107 2108 2109 2110 2111
	mutex_lock(&root->fs_info->volume_mutex);
	if (root->fs_info->balance_ctl) {
		printk(KERN_INFO "btrfs: balance in progress\n");
		ret = -EINVAL;
		goto out;
	}

L
Li Zefan 已提交
2112
	vol_args = memdup_user(arg, sizeof(*vol_args));
2113 2114 2115 2116
	if (IS_ERR(vol_args)) {
		ret = PTR_ERR(vol_args);
		goto out;
	}
C
Christoph Hellwig 已提交
2117

2118
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
2119 2120 2121
	ret = btrfs_init_new_device(root, vol_args->name);

	kfree(vol_args);
2122 2123
out:
	mutex_unlock(&root->fs_info->volume_mutex);
C
Christoph Hellwig 已提交
2124 2125 2126
	return ret;
}

2127
static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
C
Christoph Hellwig 已提交
2128 2129 2130 2131
{
	struct btrfs_ioctl_vol_args *vol_args;
	int ret;

2132 2133 2134
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

Y
Yan Zheng 已提交
2135 2136 2137
	if (root->fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

2138 2139 2140 2141 2142 2143 2144
	mutex_lock(&root->fs_info->volume_mutex);
	if (root->fs_info->balance_ctl) {
		printk(KERN_INFO "btrfs: balance in progress\n");
		ret = -EINVAL;
		goto out;
	}

L
Li Zefan 已提交
2145
	vol_args = memdup_user(arg, sizeof(*vol_args));
2146 2147 2148 2149
	if (IS_ERR(vol_args)) {
		ret = PTR_ERR(vol_args);
		goto out;
	}
C
Christoph Hellwig 已提交
2150

2151
	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
C
Christoph Hellwig 已提交
2152 2153 2154
	ret = btrfs_rm_device(root, vol_args->name);

	kfree(vol_args);
2155 2156
out:
	mutex_unlock(&root->fs_info->volume_mutex);
C
Christoph Hellwig 已提交
2157 2158 2159
	return ret;
}

J
Jan Schmidt 已提交
2160 2161
static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
{
2162
	struct btrfs_ioctl_fs_info_args *fi_args;
J
Jan Schmidt 已提交
2163 2164 2165
	struct btrfs_device *device;
	struct btrfs_device *next;
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
2166
	int ret = 0;
J
Jan Schmidt 已提交
2167 2168 2169 2170

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

2171 2172 2173 2174 2175 2176
	fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
	if (!fi_args)
		return -ENOMEM;

	fi_args->num_devices = fs_devices->num_devices;
	memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
J
Jan Schmidt 已提交
2177 2178 2179

	mutex_lock(&fs_devices->device_list_mutex);
	list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
2180 2181
		if (device->devid > fi_args->max_id)
			fi_args->max_id = device->devid;
J
Jan Schmidt 已提交
2182 2183 2184
	}
	mutex_unlock(&fs_devices->device_list_mutex);

2185 2186
	if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
		ret = -EFAULT;
J
Jan Schmidt 已提交
2187

2188 2189
	kfree(fi_args);
	return ret;
J
Jan Schmidt 已提交
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
}

static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
{
	struct btrfs_ioctl_dev_info_args *di_args;
	struct btrfs_device *dev;
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	int ret = 0;
	char *s_uuid = NULL;
	char empty_uuid[BTRFS_UUID_SIZE] = {0};

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	di_args = memdup_user(arg, sizeof(*di_args));
	if (IS_ERR(di_args))
		return PTR_ERR(di_args);

	if (memcmp(empty_uuid, di_args->uuid, BTRFS_UUID_SIZE) != 0)
		s_uuid = di_args->uuid;

	mutex_lock(&fs_devices->device_list_mutex);
	dev = btrfs_find_device(root, di_args->devid, s_uuid, NULL);
	mutex_unlock(&fs_devices->device_list_mutex);

	if (!dev) {
		ret = -ENODEV;
		goto out;
	}

	di_args->devid = dev->devid;
	di_args->bytes_used = dev->bytes_used;
	di_args->total_bytes = dev->total_bytes;
	memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
	strncpy(di_args->path, dev->name, sizeof(di_args->path));

out:
	if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
		ret = -EFAULT;

	kfree(di_args);
	return ret;
}

2234 2235
static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
				       u64 off, u64 olen, u64 destoff)
C
Christoph Hellwig 已提交
2236 2237 2238 2239 2240 2241 2242 2243
{
	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 已提交
2244 2245
	char *buf;
	struct btrfs_key key;
C
Christoph Hellwig 已提交
2246 2247
	u32 nritems;
	int slot;
Y
Yan Zheng 已提交
2248
	int ret;
2249 2250 2251
	u64 len = olen;
	u64 bs = root->fs_info->sb->s_blocksize;
	u64 hint_byte;
2252

2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
	/*
	 * 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)?
	 */

2263
	/* the destination must be opened for writing */
2264
	if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND))
2265 2266
		return -EINVAL;

L
Li Zefan 已提交
2267 2268 2269
	if (btrfs_root_readonly(root))
		return -EROFS;

2270
	ret = mnt_want_write_file(file);
Y
Yan Zheng 已提交
2271 2272 2273
	if (ret)
		return ret;

2274
	src_file = fget(srcfd);
2275 2276 2277 2278
	if (!src_file) {
		ret = -EBADF;
		goto out_drop_write;
	}
2279

C
Christoph Hellwig 已提交
2280 2281
	src = src_file->f_dentry->d_inode;

2282 2283 2284 2285
	ret = -EINVAL;
	if (src == inode)
		goto out_fput;

2286 2287 2288 2289
	/* the src must be open for reading */
	if (!(src_file->f_mode & FMODE_READ))
		goto out_fput;

2290 2291 2292 2293 2294
	/* don't make the dst file partly checksummed */
	if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
	    (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
		goto out_fput;

Y
Yan Zheng 已提交
2295 2296 2297 2298
	ret = -EISDIR;
	if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
		goto out_fput;

C
Christoph Hellwig 已提交
2299
	ret = -EXDEV;
Y
Yan Zheng 已提交
2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
	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 已提交
2311
		goto out_fput;
Y
Yan Zheng 已提交
2312 2313
	}
	path->reada = 2;
C
Christoph Hellwig 已提交
2314 2315

	if (inode < src) {
2316 2317
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD);
C
Christoph Hellwig 已提交
2318
	} else {
2319 2320
		mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
C
Christoph Hellwig 已提交
2321 2322
	}

2323 2324
	/* determine range to clone */
	ret = -EINVAL;
2325
	if (off + len > src->i_size || off + len < off)
C
Christoph Hellwig 已提交
2326
		goto out_unlock;
2327 2328 2329 2330
	if (len == 0)
		olen = len = src->i_size - off;
	/* if we extend to eof, continue to block boundary */
	if (off + len == src->i_size)
2331
		len = ALIGN(src->i_size, bs) - off;
2332 2333

	/* verify the end result is block aligned */
2334 2335
	if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) ||
	    !IS_ALIGNED(destoff, bs))
2336 2337
		goto out_unlock;

2338 2339 2340 2341 2342 2343
	if (destoff > inode->i_size) {
		ret = btrfs_cont_expand(inode, inode->i_size, destoff);
		if (ret)
			goto out_unlock;
	}

2344 2345 2346 2347
	/* truncate page cache pages from target inode range */
	truncate_inode_pages_range(&inode->i_data, destoff,
				   PAGE_CACHE_ALIGN(destoff + len) - 1);

C
Christoph Hellwig 已提交
2348 2349 2350
	/* do any pending delalloc/csum calc on src, one way or
	   another, and lock file content */
	while (1) {
Z
Zheng Yan 已提交
2351
		struct btrfs_ordered_extent *ordered;
2352
		lock_extent(&BTRFS_I(src)->io_tree, off, off+len);
2353 2354 2355 2356
		ordered = btrfs_lookup_first_ordered_extent(src, off+len);
		if (!ordered &&
		    !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len,
				   EXTENT_DELALLOC, 0, NULL))
C
Christoph Hellwig 已提交
2357
			break;
2358
		unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
Y
Yan Zheng 已提交
2359 2360
		if (ordered)
			btrfs_put_ordered_extent(ordered);
2361
		btrfs_wait_ordered_range(src, off, len);
C
Christoph Hellwig 已提交
2362 2363
	}

2364
	/* clone data */
L
Li Zefan 已提交
2365
	key.objectid = btrfs_ino(src);
Y
Yan Zheng 已提交
2366 2367
	key.type = BTRFS_EXTENT_DATA_KEY;
	key.offset = 0;
C
Christoph Hellwig 已提交
2368 2369 2370 2371 2372 2373

	while (1) {
		/*
		 * note the key will change type as we walk through the
		 * tree.
		 */
2374
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
C
Christoph Hellwig 已提交
2375 2376 2377
		if (ret < 0)
			goto out;

Y
Yan Zheng 已提交
2378 2379
		nritems = btrfs_header_nritems(path->nodes[0]);
		if (path->slots[0] >= nritems) {
C
Christoph Hellwig 已提交
2380 2381 2382 2383 2384
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				goto out;
			if (ret > 0)
				break;
Y
Yan Zheng 已提交
2385
			nritems = btrfs_header_nritems(path->nodes[0]);
C
Christoph Hellwig 已提交
2386 2387 2388 2389
		}
		leaf = path->nodes[0];
		slot = path->slots[0];

Y
Yan Zheng 已提交
2390
		btrfs_item_key_to_cpu(leaf, &key, slot);
2391
		if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
L
Li Zefan 已提交
2392
		    key.objectid != btrfs_ino(src))
C
Christoph Hellwig 已提交
2393 2394
			break;

2395 2396 2397
		if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
			struct btrfs_file_extent_item *extent;
			int type;
Z
Zheng Yan 已提交
2398 2399
			u32 size;
			struct btrfs_key new_key;
2400 2401 2402
			u64 disko = 0, diskl = 0;
			u64 datao = 0, datal = 0;
			u8 comp;
2403
			u64 endoff;
Z
Zheng Yan 已提交
2404 2405 2406 2407 2408

			size = btrfs_item_size_nr(leaf, slot);
			read_extent_buffer(leaf, buf,
					   btrfs_item_ptr_offset(leaf, slot),
					   size);
2409 2410 2411 2412 2413

			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);
2414 2415
			if (type == BTRFS_FILE_EXTENT_REG ||
			    type == BTRFS_FILE_EXTENT_PREALLOC) {
C
Chris Mason 已提交
2416 2417 2418 2419
				disko = btrfs_file_extent_disk_bytenr(leaf,
								      extent);
				diskl = btrfs_file_extent_disk_num_bytes(leaf,
								 extent);
2420
				datao = btrfs_file_extent_offset(leaf, extent);
C
Chris Mason 已提交
2421 2422
				datal = btrfs_file_extent_num_bytes(leaf,
								    extent);
2423 2424 2425 2426 2427
			} else if (type == BTRFS_FILE_EXTENT_INLINE) {
				/* take upper bound, may be compressed */
				datal = btrfs_file_extent_ram_bytes(leaf,
								    extent);
			}
2428
			btrfs_release_path(path);
Z
Zheng Yan 已提交
2429

2430
			if (key.offset + datal <= off ||
2431 2432 2433
			    key.offset >= off+len)
				goto next;

Z
Zheng Yan 已提交
2434
			memcpy(&new_key, &key, sizeof(new_key));
L
Li Zefan 已提交
2435
			new_key.objectid = btrfs_ino(inode);
2436 2437 2438 2439
			if (off <= key.offset)
				new_key.offset = key.offset + destoff - off;
			else
				new_key.offset = destoff;
Z
Zheng Yan 已提交
2440

2441 2442 2443 2444 2445 2446
			/*
			 * 1 - adjusting old extent (we may have to split it)
			 * 1 - add new extent
			 * 1 - inode update
			 */
			trans = btrfs_start_transaction(root, 3);
2447 2448 2449 2450 2451
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				goto out;
			}

2452 2453
			if (type == BTRFS_FILE_EXTENT_REG ||
			    type == BTRFS_FILE_EXTENT_PREALLOC) {
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
				/*
				 *    a  | --- range to clone ---|  b
				 * | ------------- extent ------------- |
				 */

				/* substract range b */
				if (key.offset + datal > off + len)
					datal = off + len - key.offset;

				/* substract range a */
2464 2465 2466 2467 2468 2469 2470 2471 2472
				if (off > key.offset) {
					datao += off - key.offset;
					datal -= off - key.offset;
				}

				ret = btrfs_drop_extents(trans, inode,
							 new_key.offset,
							 new_key.offset + datal,
							 &hint_byte, 1);
2473 2474 2475 2476 2477 2478
				if (ret) {
					btrfs_abort_transaction(trans, root,
								ret);
					btrfs_end_transaction(trans, root);
					goto out;
				}
2479

2480 2481
				ret = btrfs_insert_empty_item(trans, root, path,
							      &new_key, size);
2482 2483 2484 2485 2486 2487
				if (ret) {
					btrfs_abort_transaction(trans, root,
								ret);
					btrfs_end_transaction(trans, root);
					goto out;
				}
2488 2489 2490 2491

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

2495
				extent = btrfs_item_ptr(leaf, slot,
C
Christoph Hellwig 已提交
2496
						struct btrfs_file_extent_item);
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507

				/* disko == 0 means it's a hole */
				if (!disko)
					datao = 0;

				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 已提交
2508
					ret = btrfs_inc_extent_ref(trans, root,
2509 2510
							disko, diskl, 0,
							root->root_key.objectid,
L
Li Zefan 已提交
2511
							btrfs_ino(inode),
A
Arne Jansen 已提交
2512 2513
							new_key.offset - datao,
							0);
2514 2515 2516 2517 2518 2519 2520 2521 2522
					if (ret) {
						btrfs_abort_transaction(trans,
									root,
									ret);
						btrfs_end_transaction(trans,
								      root);
						goto out;

					}
C
Christoph Hellwig 已提交
2523
				}
2524 2525 2526 2527 2528 2529 2530
			} 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;
				}
C
Chris Mason 已提交
2531

2532 2533
				if (key.offset + datal > off+len)
					trim = key.offset + datal - (off+len);
C
Chris Mason 已提交
2534

2535 2536
				if (comp && (skip || trim)) {
					ret = -EINVAL;
2537
					btrfs_end_transaction(trans, root);
2538 2539 2540 2541
					goto out;
				}
				size -= skip + trim;
				datal -= skip + trim;
2542 2543 2544 2545 2546

				ret = btrfs_drop_extents(trans, inode,
							 new_key.offset,
							 new_key.offset + datal,
							 &hint_byte, 1);
2547 2548 2549 2550 2551 2552
				if (ret) {
					btrfs_abort_transaction(trans, root,
								ret);
					btrfs_end_transaction(trans, root);
					goto out;
				}
2553

2554 2555
				ret = btrfs_insert_empty_item(trans, root, path,
							      &new_key, size);
2556 2557 2558 2559 2560 2561
				if (ret) {
					btrfs_abort_transaction(trans, root,
								ret);
					btrfs_end_transaction(trans, root);
					goto out;
				}
2562 2563

				if (skip) {
C
Chris Mason 已提交
2564 2565
					u32 start =
					  btrfs_file_extent_calc_inline_size(0);
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
					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 已提交
2576
			}
2577 2578

			btrfs_mark_buffer_dirty(leaf);
2579
			btrfs_release_path(path);
2580

2581
			inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2582 2583 2584 2585 2586 2587 2588

			/*
			 * we round up to the block size at eof when
			 * determining which extents to clone above,
			 * but shouldn't round up the file size
			 */
			endoff = new_key.offset + datal;
2589 2590
			if (endoff > destoff+olen)
				endoff = destoff+olen;
2591 2592 2593
			if (endoff > inode->i_size)
				btrfs_i_size_write(inode, endoff);

2594
			ret = btrfs_update_inode(trans, root, inode);
2595 2596 2597 2598 2599 2600
			if (ret) {
				btrfs_abort_transaction(trans, root, ret);
				btrfs_end_transaction(trans, root);
				goto out;
			}
			ret = btrfs_end_transaction(trans, root);
2601
		}
C
Chris Mason 已提交
2602
next:
2603
		btrfs_release_path(path);
C
Christoph Hellwig 已提交
2604 2605 2606 2607
		key.offset++;
	}
	ret = 0;
out:
2608
	btrfs_release_path(path);
2609
	unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
C
Christoph Hellwig 已提交
2610 2611 2612
out_unlock:
	mutex_unlock(&src->i_mutex);
	mutex_unlock(&inode->i_mutex);
Y
Yan Zheng 已提交
2613 2614
	vfree(buf);
	btrfs_free_path(path);
C
Christoph Hellwig 已提交
2615 2616
out_fput:
	fput(src_file);
2617
out_drop_write:
A
Al Viro 已提交
2618
	mnt_drop_write_file(file);
C
Christoph Hellwig 已提交
2619 2620 2621
	return ret;
}

2622
static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
2623 2624 2625
{
	struct btrfs_ioctl_clone_range_args args;

2626
	if (copy_from_user(&args, argp, sizeof(args)))
2627 2628 2629 2630 2631
		return -EFAULT;
	return btrfs_ioctl_clone(file, args.src_fd, args.src_offset,
				 args.src_length, args.dest_offset);
}

C
Christoph Hellwig 已提交
2632 2633 2634 2635 2636 2637
/*
 * 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.
 */
2638
static long btrfs_ioctl_trans_start(struct file *file)
C
Christoph Hellwig 已提交
2639 2640 2641 2642
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_trans_handle *trans;
2643
	int ret;
C
Christoph Hellwig 已提交
2644

2645
	ret = -EPERM;
2646
	if (!capable(CAP_SYS_ADMIN))
2647
		goto out;
2648

2649 2650
	ret = -EINPROGRESS;
	if (file->private_data)
C
Christoph Hellwig 已提交
2651
		goto out;
2652

L
Li Zefan 已提交
2653 2654 2655 2656
	ret = -EROFS;
	if (btrfs_root_readonly(root))
		goto out;

2657
	ret = mnt_want_write_file(file);
Y
Yan Zheng 已提交
2658 2659 2660
	if (ret)
		goto out;

J
Josef Bacik 已提交
2661
	atomic_inc(&root->fs_info->open_ioctl_trans);
2662

2663
	ret = -ENOMEM;
2664
	trans = btrfs_start_ioctl_transaction(root);
2665
	if (IS_ERR(trans))
2666 2667 2668 2669 2670 2671
		goto out_drop;

	file->private_data = trans;
	return 0;

out_drop:
J
Josef Bacik 已提交
2672
	atomic_dec(&root->fs_info->open_ioctl_trans);
A
Al Viro 已提交
2673
	mnt_drop_write_file(file);
C
Christoph Hellwig 已提交
2674 2675 2676 2677
out:
	return ret;
}

2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 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
static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
{
	struct inode *inode = fdentry(file)->d_inode;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct btrfs_root *new_root;
	struct btrfs_dir_item *di;
	struct btrfs_trans_handle *trans;
	struct btrfs_path *path;
	struct btrfs_key location;
	struct btrfs_disk_key disk_key;
	struct btrfs_super_block *disk_super;
	u64 features;
	u64 objectid = 0;
	u64 dir_id;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (copy_from_user(&objectid, argp, sizeof(objectid)))
		return -EFAULT;

	if (!objectid)
		objectid = root->root_key.objectid;

	location.objectid = objectid;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = (u64)-1;

	new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
	if (IS_ERR(new_root))
		return PTR_ERR(new_root);

	if (btrfs_root_refs(&new_root->root_item) == 0)
		return -ENOENT;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->leave_spinning = 1;

	trans = btrfs_start_transaction(root, 1);
2719
	if (IS_ERR(trans)) {
2720
		btrfs_free_path(path);
2721
		return PTR_ERR(trans);
2722 2723
	}

2724
	dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
2725 2726
	di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path,
				   dir_id, "default", 7, 1);
2727
	if (IS_ERR_OR_NULL(di)) {
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
		btrfs_free_path(path);
		btrfs_end_transaction(trans, root);
		printk(KERN_ERR "Umm, you don't have the default dir item, "
		       "this isn't going to work\n");
		return -ENOENT;
	}

	btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
	btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_free_path(path);

2740
	disk_super = root->fs_info->super_copy;
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
	features = btrfs_super_incompat_flags(disk_super);
	if (!(features & BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)) {
		features |= BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL;
		btrfs_set_super_incompat_flags(disk_super, features);
	}
	btrfs_end_transaction(trans, root);

	return 0;
}

2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
static void get_block_group_info(struct list_head *groups_list,
				 struct btrfs_ioctl_space_info *space)
{
	struct btrfs_block_group_cache *block_group;

	space->total_bytes = 0;
	space->used_bytes = 0;
	space->flags = 0;
	list_for_each_entry(block_group, groups_list, list) {
		space->flags = block_group->flags;
		space->total_bytes += block_group->key.offset;
		space->used_bytes +=
			btrfs_block_group_used(&block_group->item);
	}
}

J
Josef Bacik 已提交
2767 2768 2769 2770 2771
long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
{
	struct btrfs_ioctl_space_args space_args;
	struct btrfs_ioctl_space_info space;
	struct btrfs_ioctl_space_info *dest;
2772
	struct btrfs_ioctl_space_info *dest_orig;
2773
	struct btrfs_ioctl_space_info __user *user_dest;
J
Josef Bacik 已提交
2774
	struct btrfs_space_info *info;
2775 2776 2777 2778 2779
	u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
		       BTRFS_BLOCK_GROUP_SYSTEM,
		       BTRFS_BLOCK_GROUP_METADATA,
		       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
	int num_types = 4;
2780
	int alloc_size;
J
Josef Bacik 已提交
2781
	int ret = 0;
2782
	u64 slot_count = 0;
2783
	int i, c;
J
Josef Bacik 已提交
2784 2785 2786 2787 2788 2789

	if (copy_from_user(&space_args,
			   (struct btrfs_ioctl_space_args __user *)arg,
			   sizeof(space_args)))
		return -EFAULT;

2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
	for (i = 0; i < num_types; i++) {
		struct btrfs_space_info *tmp;

		info = NULL;
		rcu_read_lock();
		list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
					list) {
			if (tmp->flags == types[i]) {
				info = tmp;
				break;
			}
		}
		rcu_read_unlock();

		if (!info)
			continue;

		down_read(&info->groups_sem);
		for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
			if (!list_empty(&info->block_groups[c]))
				slot_count++;
		}
		up_read(&info->groups_sem);
	}
2814 2815 2816 2817 2818 2819

	/* space_slots == 0 means they are asking for a count */
	if (space_args.space_slots == 0) {
		space_args.total_spaces = slot_count;
		goto out;
	}
2820

2821
	slot_count = min_t(u64, space_args.space_slots, slot_count);
2822

2823
	alloc_size = sizeof(*dest) * slot_count;
2824

2825 2826 2827 2828 2829 2830
	/* we generally have at most 6 or so space infos, one for each raid
	 * level.  So, a whole page should be more than enough for everyone
	 */
	if (alloc_size > PAGE_CACHE_SIZE)
		return -ENOMEM;

J
Josef Bacik 已提交
2831
	space_args.total_spaces = 0;
2832 2833 2834 2835
	dest = kmalloc(alloc_size, GFP_NOFS);
	if (!dest)
		return -ENOMEM;
	dest_orig = dest;
J
Josef Bacik 已提交
2836

2837
	/* now we have a buffer to copy into */
2838 2839 2840
	for (i = 0; i < num_types; i++) {
		struct btrfs_space_info *tmp;

2841 2842 2843
		if (!slot_count)
			break;

2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
		info = NULL;
		rcu_read_lock();
		list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
					list) {
			if (tmp->flags == types[i]) {
				info = tmp;
				break;
			}
		}
		rcu_read_unlock();
2854

2855 2856 2857 2858 2859 2860 2861 2862 2863 2864
		if (!info)
			continue;
		down_read(&info->groups_sem);
		for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
			if (!list_empty(&info->block_groups[c])) {
				get_block_group_info(&info->block_groups[c],
						     &space);
				memcpy(dest, &space, sizeof(space));
				dest++;
				space_args.total_spaces++;
2865
				slot_count--;
2866
			}
2867 2868
			if (!slot_count)
				break;
2869 2870
		}
		up_read(&info->groups_sem);
J
Josef Bacik 已提交
2871 2872
	}

2873 2874 2875 2876 2877 2878 2879 2880 2881
	user_dest = (struct btrfs_ioctl_space_info *)
		(arg + sizeof(struct btrfs_ioctl_space_args));

	if (copy_to_user(user_dest, dest_orig, alloc_size))
		ret = -EFAULT;

	kfree(dest_orig);
out:
	if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
J
Josef Bacik 已提交
2882 2883 2884 2885 2886
		ret = -EFAULT;

	return ret;
}

C
Christoph Hellwig 已提交
2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
/*
 * 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;

	trans = file->private_data;
2900 2901
	if (!trans)
		return -EINVAL;
C
Christoph Hellwig 已提交
2902
	file->private_data = NULL;
2903

2904 2905
	btrfs_end_transaction(trans, root);

J
Josef Bacik 已提交
2906
	atomic_dec(&root->fs_info->open_ioctl_trans);
2907

A
Al Viro 已提交
2908
	mnt_drop_write_file(file);
2909
	return 0;
C
Christoph Hellwig 已提交
2910 2911
}

2912 2913 2914 2915 2916
static noinline long btrfs_ioctl_start_sync(struct file *file, void __user *argp)
{
	struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
	struct btrfs_trans_handle *trans;
	u64 transid;
T
Tsutomu Itoh 已提交
2917
	int ret;
2918 2919

	trans = btrfs_start_transaction(root, 0);
2920 2921
	if (IS_ERR(trans))
		return PTR_ERR(trans);
2922
	transid = trans->transid;
T
Tsutomu Itoh 已提交
2923
	ret = btrfs_commit_transaction_async(trans, root, 0);
2924 2925
	if (ret) {
		btrfs_end_transaction(trans, root);
T
Tsutomu Itoh 已提交
2926
		return ret;
2927
	}
2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948

	if (argp)
		if (copy_to_user(argp, &transid, sizeof(transid)))
			return -EFAULT;
	return 0;
}

static noinline long btrfs_ioctl_wait_sync(struct file *file, void __user *argp)
{
	struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
	u64 transid;

	if (argp) {
		if (copy_from_user(&transid, argp, sizeof(transid)))
			return -EFAULT;
	} else {
		transid = 0;  /* current trans */
	}
	return btrfs_wait_for_commit(root, transid);
}

J
Jan Schmidt 已提交
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg)
{
	int ret;
	struct btrfs_ioctl_scrub_args *sa;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	sa = memdup_user(arg, sizeof(*sa));
	if (IS_ERR(sa))
		return PTR_ERR(sa);

	ret = btrfs_scrub_dev(root, sa->devid, sa->start, sa->end,
A
Arne Jansen 已提交
2962
			      &sa->progress, sa->flags & BTRFS_SCRUB_READONLY);
J
Jan Schmidt 已提交
2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000

	if (copy_to_user(arg, sa, sizeof(*sa)))
		ret = -EFAULT;

	kfree(sa);
	return ret;
}

static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
{
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	return btrfs_scrub_cancel(root);
}

static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
				       void __user *arg)
{
	struct btrfs_ioctl_scrub_args *sa;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	sa = memdup_user(arg, sizeof(*sa));
	if (IS_ERR(sa))
		return PTR_ERR(sa);

	ret = btrfs_scrub_progress(root, sa->devid, &sa->progress);

	if (copy_to_user(arg, sa, sizeof(*sa)))
		ret = -EFAULT;

	kfree(sa);
	return ret;
}

3001 3002 3003 3004
static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
{
	int ret = 0;
	int i;
3005
	u64 rel_ptr;
3006
	int size;
3007
	struct btrfs_ioctl_ino_path_args *ipa = NULL;
3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
	struct inode_fs_paths *ipath = NULL;
	struct btrfs_path *path;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

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

	ipa = memdup_user(arg, sizeof(*ipa));
	if (IS_ERR(ipa)) {
		ret = PTR_ERR(ipa);
		ipa = NULL;
		goto out;
	}

	size = min_t(u32, ipa->size, 4096);
	ipath = init_ipath(size, root, path);
	if (IS_ERR(ipath)) {
		ret = PTR_ERR(ipath);
		ipath = NULL;
		goto out;
	}

	ret = paths_from_inode(ipa->inum, ipath);
	if (ret < 0)
		goto out;

	for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
3040 3041
		rel_ptr = ipath->fspath->val[i] -
			  (u64)(unsigned long)ipath->fspath->val;
3042
		ipath->fspath->val[i] = rel_ptr;
3043 3044
	}

3045 3046
	ret = copy_to_user((void *)(unsigned long)ipa->fspath,
			   (void *)(unsigned long)ipath->fspath, size);
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
	if (ret) {
		ret = -EFAULT;
		goto out;
	}

out:
	btrfs_free_path(path);
	free_ipath(ipath);
	kfree(ipa);

	return ret;
}

static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx)
{
	struct btrfs_data_container *inodes = ctx;
	const size_t c = 3 * sizeof(u64);

	if (inodes->bytes_left >= c) {
		inodes->bytes_left -= c;
		inodes->val[inodes->elem_cnt] = inum;
		inodes->val[inodes->elem_cnt + 1] = offset;
		inodes->val[inodes->elem_cnt + 2] = root;
		inodes->elem_cnt += 3;
	} else {
		inodes->bytes_missing += c - inodes->bytes_left;
		inodes->bytes_left = 0;
		inodes->elem_missed += 3;
	}

	return 0;
}

static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
					void __user *arg)
{
	int ret = 0;
	int size;
J
Jan Schmidt 已提交
3085
	u64 extent_item_pos;
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
	struct btrfs_ioctl_logical_ino_args *loi;
	struct btrfs_data_container *inodes = NULL;
	struct btrfs_path *path = NULL;
	struct btrfs_key key;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	loi = memdup_user(arg, sizeof(*loi));
	if (IS_ERR(loi)) {
		ret = PTR_ERR(loi);
		loi = NULL;
		goto out;
	}

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

	size = min_t(u32, loi->size, 4096);
	inodes = init_data_container(size);
	if (IS_ERR(inodes)) {
		ret = PTR_ERR(inodes);
		inodes = NULL;
		goto out;
	}

	ret = extent_from_logical(root->fs_info, loi->logical, path, &key);
J
Jan Schmidt 已提交
3116
	btrfs_release_path(path);
3117 3118 3119 3120 3121 3122

	if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK)
		ret = -ENOENT;
	if (ret < 0)
		goto out;

J
Jan Schmidt 已提交
3123
	extent_item_pos = loi->logical - key.objectid;
3124 3125
	ret = iterate_extent_inodes(root->fs_info, key.objectid,
					extent_item_pos, 0, build_ino_list,
J
Jan Schmidt 已提交
3126
					inodes);
3127 3128 3129 3130

	if (ret < 0)
		goto out;

3131 3132
	ret = copy_to_user((void *)(unsigned long)loi->inodes,
			   (void *)(unsigned long)inodes, size);
3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143
	if (ret)
		ret = -EFAULT;

out:
	btrfs_free_path(path);
	kfree(inodes);
	kfree(loi);

	return ret;
}

3144
void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
3145 3146 3147 3148 3149 3150
			       struct btrfs_ioctl_balance_args *bargs)
{
	struct btrfs_balance_control *bctl = fs_info->balance_ctl;

	bargs->flags = bctl->flags;

3151 3152 3153 3154
	if (atomic_read(&fs_info->balance_running))
		bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
	if (atomic_read(&fs_info->balance_pause_req))
		bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
3155 3156
	if (atomic_read(&fs_info->balance_cancel_req))
		bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
3157

3158 3159 3160
	memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
	memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
	memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
3161 3162 3163 3164 3165 3166 3167 3168

	if (lock) {
		spin_lock(&fs_info->balance_lock);
		memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
		spin_unlock(&fs_info->balance_lock);
	} else {
		memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
	}
3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192
}

static long btrfs_ioctl_balance(struct btrfs_root *root, void __user *arg)
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_ioctl_balance_args *bargs;
	struct btrfs_balance_control *bctl;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

	mutex_lock(&fs_info->volume_mutex);
	mutex_lock(&fs_info->balance_mutex);

	if (arg) {
		bargs = memdup_user(arg, sizeof(*bargs));
		if (IS_ERR(bargs)) {
			ret = PTR_ERR(bargs);
			goto out;
		}
3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206

		if (bargs->flags & BTRFS_BALANCE_RESUME) {
			if (!fs_info->balance_ctl) {
				ret = -ENOTCONN;
				goto out_bargs;
			}

			bctl = fs_info->balance_ctl;
			spin_lock(&fs_info->balance_lock);
			bctl->flags |= BTRFS_BALANCE_RESUME;
			spin_unlock(&fs_info->balance_lock);

			goto do_balance;
		}
3207 3208 3209 3210
	} else {
		bargs = NULL;
	}

3211 3212 3213 3214 3215
	if (fs_info->balance_ctl) {
		ret = -EINPROGRESS;
		goto out_bargs;
	}

3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228
	bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
	if (!bctl) {
		ret = -ENOMEM;
		goto out_bargs;
	}

	bctl->fs_info = fs_info;
	if (arg) {
		memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
		memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
		memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));

		bctl->flags = bargs->flags;
3229 3230 3231
	} else {
		/* balance everything - no filters */
		bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
3232 3233
	}

3234
do_balance:
3235 3236
	ret = btrfs_balance(bctl, bargs);
	/*
3237 3238
	 * bctl is freed in __cancel_balance or in free_fs_info if
	 * restriper was paused all the way until unmount
3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
	 */
	if (arg) {
		if (copy_to_user(arg, bargs, sizeof(*bargs)))
			ret = -EFAULT;
	}

out_bargs:
	kfree(bargs);
out:
	mutex_unlock(&fs_info->balance_mutex);
	mutex_unlock(&fs_info->volume_mutex);
	return ret;
}

3253 3254 3255 3256 3257 3258 3259 3260
static long btrfs_ioctl_balance_ctl(struct btrfs_root *root, int cmd)
{
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	switch (cmd) {
	case BTRFS_BALANCE_CTL_PAUSE:
		return btrfs_pause_balance(root->fs_info);
3261 3262
	case BTRFS_BALANCE_CTL_CANCEL:
		return btrfs_cancel_balance(root->fs_info);
3263 3264 3265 3266 3267
	}

	return -EINVAL;
}

3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300
static long btrfs_ioctl_balance_progress(struct btrfs_root *root,
					 void __user *arg)
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_ioctl_balance_args *bargs;
	int ret = 0;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	mutex_lock(&fs_info->balance_mutex);
	if (!fs_info->balance_ctl) {
		ret = -ENOTCONN;
		goto out;
	}

	bargs = kzalloc(sizeof(*bargs), GFP_NOFS);
	if (!bargs) {
		ret = -ENOMEM;
		goto out;
	}

	update_ioctl_balance_args(fs_info, 1, bargs);

	if (copy_to_user(arg, bargs, sizeof(*bargs)))
		ret = -EFAULT;

	kfree(bargs);
out:
	mutex_unlock(&fs_info->balance_mutex);
	return ret;
}

C
Christoph Hellwig 已提交
3301 3302 3303 3304
long btrfs_ioctl(struct file *file, unsigned int
		cmd, unsigned long arg)
{
	struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
3305
	void __user *argp = (void __user *)arg;
C
Christoph Hellwig 已提交
3306 3307

	switch (cmd) {
3308 3309 3310 3311 3312 3313
	case FS_IOC_GETFLAGS:
		return btrfs_ioctl_getflags(file, argp);
	case FS_IOC_SETFLAGS:
		return btrfs_ioctl_setflags(file, argp);
	case FS_IOC_GETVERSION:
		return btrfs_ioctl_getversion(file, argp);
3314 3315
	case FITRIM:
		return btrfs_ioctl_fitrim(file, argp);
C
Christoph Hellwig 已提交
3316
	case BTRFS_IOC_SNAP_CREATE:
3317
		return btrfs_ioctl_snap_create(file, argp, 0);
3318
	case BTRFS_IOC_SNAP_CREATE_V2:
3319
		return btrfs_ioctl_snap_create_v2(file, argp, 0);
3320
	case BTRFS_IOC_SUBVOL_CREATE:
3321
		return btrfs_ioctl_snap_create(file, argp, 1);
3322 3323
	case BTRFS_IOC_SNAP_DESTROY:
		return btrfs_ioctl_snap_destroy(file, argp);
3324 3325 3326 3327
	case BTRFS_IOC_SUBVOL_GETFLAGS:
		return btrfs_ioctl_subvol_getflags(file, argp);
	case BTRFS_IOC_SUBVOL_SETFLAGS:
		return btrfs_ioctl_subvol_setflags(file, argp);
3328 3329
	case BTRFS_IOC_DEFAULT_SUBVOL:
		return btrfs_ioctl_default_subvol(file, argp);
C
Christoph Hellwig 已提交
3330
	case BTRFS_IOC_DEFRAG:
C
Chris Mason 已提交
3331 3332 3333
		return btrfs_ioctl_defrag(file, NULL);
	case BTRFS_IOC_DEFRAG_RANGE:
		return btrfs_ioctl_defrag(file, argp);
C
Christoph Hellwig 已提交
3334
	case BTRFS_IOC_RESIZE:
3335
		return btrfs_ioctl_resize(root, argp);
C
Christoph Hellwig 已提交
3336
	case BTRFS_IOC_ADD_DEV:
3337
		return btrfs_ioctl_add_dev(root, argp);
C
Christoph Hellwig 已提交
3338
	case BTRFS_IOC_RM_DEV:
3339
		return btrfs_ioctl_rm_dev(root, argp);
J
Jan Schmidt 已提交
3340 3341 3342 3343
	case BTRFS_IOC_FS_INFO:
		return btrfs_ioctl_fs_info(root, argp);
	case BTRFS_IOC_DEV_INFO:
		return btrfs_ioctl_dev_info(root, argp);
C
Christoph Hellwig 已提交
3344
	case BTRFS_IOC_BALANCE:
3345
		return btrfs_ioctl_balance(root, NULL);
C
Christoph Hellwig 已提交
3346
	case BTRFS_IOC_CLONE:
3347 3348
		return btrfs_ioctl_clone(file, arg, 0, 0, 0);
	case BTRFS_IOC_CLONE_RANGE:
3349
		return btrfs_ioctl_clone_range(file, argp);
C
Christoph Hellwig 已提交
3350 3351 3352 3353
	case BTRFS_IOC_TRANS_START:
		return btrfs_ioctl_trans_start(file);
	case BTRFS_IOC_TRANS_END:
		return btrfs_ioctl_trans_end(file);
3354 3355 3356 3357
	case BTRFS_IOC_TREE_SEARCH:
		return btrfs_ioctl_tree_search(file, argp);
	case BTRFS_IOC_INO_LOOKUP:
		return btrfs_ioctl_ino_lookup(file, argp);
3358 3359 3360 3361
	case BTRFS_IOC_INO_PATHS:
		return btrfs_ioctl_ino_to_path(root, argp);
	case BTRFS_IOC_LOGICAL_INO:
		return btrfs_ioctl_logical_to_ino(root, argp);
J
Josef Bacik 已提交
3362 3363
	case BTRFS_IOC_SPACE_INFO:
		return btrfs_ioctl_space_info(root, argp);
C
Christoph Hellwig 已提交
3364 3365 3366
	case BTRFS_IOC_SYNC:
		btrfs_sync_fs(file->f_dentry->d_sb, 1);
		return 0;
3367 3368 3369 3370
	case BTRFS_IOC_START_SYNC:
		return btrfs_ioctl_start_sync(file, argp);
	case BTRFS_IOC_WAIT_SYNC:
		return btrfs_ioctl_wait_sync(file, argp);
J
Jan Schmidt 已提交
3371 3372 3373 3374 3375 3376
	case BTRFS_IOC_SCRUB:
		return btrfs_ioctl_scrub(root, argp);
	case BTRFS_IOC_SCRUB_CANCEL:
		return btrfs_ioctl_scrub_cancel(root, argp);
	case BTRFS_IOC_SCRUB_PROGRESS:
		return btrfs_ioctl_scrub_progress(root, argp);
3377 3378
	case BTRFS_IOC_BALANCE_V2:
		return btrfs_ioctl_balance(root, argp);
3379 3380
	case BTRFS_IOC_BALANCE_CTL:
		return btrfs_ioctl_balance_ctl(root, arg);
3381 3382
	case BTRFS_IOC_BALANCE_PROGRESS:
		return btrfs_ioctl_balance_progress(root, argp);
C
Christoph Hellwig 已提交
3383 3384 3385 3386
	}

	return -ENOTTY;
}