xref: /linux/fs/btrfs/ioctl.c (revision 04eeb606a8383b306f4bc6991da8231b5f3924b0)
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/bio.h>
21 #include <linux/buffer_head.h>
22 #include <linux/file.h>
23 #include <linux/fs.h>
24 #include <linux/fsnotify.h>
25 #include <linux/pagemap.h>
26 #include <linux/highmem.h>
27 #include <linux/time.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/backing-dev.h>
31 #include <linux/mount.h>
32 #include <linux/mpage.h>
33 #include <linux/namei.h>
34 #include <linux/swap.h>
35 #include <linux/writeback.h>
36 #include <linux/statfs.h>
37 #include <linux/compat.h>
38 #include <linux/bit_spinlock.h>
39 #include <linux/security.h>
40 #include <linux/xattr.h>
41 #include <linux/vmalloc.h>
42 #include <linux/slab.h>
43 #include <linux/blkdev.h>
44 #include <linux/uuid.h>
45 #include <linux/btrfs.h>
46 #include <linux/uaccess.h>
47 #include "ctree.h"
48 #include "disk-io.h"
49 #include "transaction.h"
50 #include "btrfs_inode.h"
51 #include "print-tree.h"
52 #include "volumes.h"
53 #include "locking.h"
54 #include "inode-map.h"
55 #include "backref.h"
56 #include "rcu-string.h"
57 #include "send.h"
58 #include "dev-replace.h"
59 #include "props.h"
60 #include "sysfs.h"
61 #include "qgroup.h"
62 
63 #ifdef CONFIG_64BIT
64 /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI
65  * structures are incorrect, as the timespec structure from userspace
66  * is 4 bytes too small. We define these alternatives here to teach
67  * the kernel about the 32-bit struct packing.
68  */
69 struct btrfs_ioctl_timespec_32 {
70 	__u64 sec;
71 	__u32 nsec;
72 } __attribute__ ((__packed__));
73 
74 struct btrfs_ioctl_received_subvol_args_32 {
75 	char	uuid[BTRFS_UUID_SIZE];	/* in */
76 	__u64	stransid;		/* in */
77 	__u64	rtransid;		/* out */
78 	struct btrfs_ioctl_timespec_32 stime; /* in */
79 	struct btrfs_ioctl_timespec_32 rtime; /* out */
80 	__u64	flags;			/* in */
81 	__u64	reserved[16];		/* in */
82 } __attribute__ ((__packed__));
83 
84 #define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 _IOWR(BTRFS_IOCTL_MAGIC, 37, \
85 				struct btrfs_ioctl_received_subvol_args_32)
86 #endif
87 
88 
89 static int btrfs_clone(struct inode *src, struct inode *inode,
90 		       u64 off, u64 olen, u64 olen_aligned, u64 destoff);
91 
92 /* Mask out flags that are inappropriate for the given type of inode. */
93 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
94 {
95 	if (S_ISDIR(mode))
96 		return flags;
97 	else if (S_ISREG(mode))
98 		return flags & ~FS_DIRSYNC_FL;
99 	else
100 		return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
101 }
102 
103 /*
104  * Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl.
105  */
106 static unsigned int btrfs_flags_to_ioctl(unsigned int flags)
107 {
108 	unsigned int iflags = 0;
109 
110 	if (flags & BTRFS_INODE_SYNC)
111 		iflags |= FS_SYNC_FL;
112 	if (flags & BTRFS_INODE_IMMUTABLE)
113 		iflags |= FS_IMMUTABLE_FL;
114 	if (flags & BTRFS_INODE_APPEND)
115 		iflags |= FS_APPEND_FL;
116 	if (flags & BTRFS_INODE_NODUMP)
117 		iflags |= FS_NODUMP_FL;
118 	if (flags & BTRFS_INODE_NOATIME)
119 		iflags |= FS_NOATIME_FL;
120 	if (flags & BTRFS_INODE_DIRSYNC)
121 		iflags |= FS_DIRSYNC_FL;
122 	if (flags & BTRFS_INODE_NODATACOW)
123 		iflags |= FS_NOCOW_FL;
124 
125 	if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS))
126 		iflags |= FS_COMPR_FL;
127 	else if (flags & BTRFS_INODE_NOCOMPRESS)
128 		iflags |= FS_NOCOMP_FL;
129 
130 	return iflags;
131 }
132 
133 /*
134  * Update inode->i_flags based on the btrfs internal flags.
135  */
136 void btrfs_update_iflags(struct inode *inode)
137 {
138 	struct btrfs_inode *ip = BTRFS_I(inode);
139 	unsigned int new_fl = 0;
140 
141 	if (ip->flags & BTRFS_INODE_SYNC)
142 		new_fl |= S_SYNC;
143 	if (ip->flags & BTRFS_INODE_IMMUTABLE)
144 		new_fl |= S_IMMUTABLE;
145 	if (ip->flags & BTRFS_INODE_APPEND)
146 		new_fl |= S_APPEND;
147 	if (ip->flags & BTRFS_INODE_NOATIME)
148 		new_fl |= S_NOATIME;
149 	if (ip->flags & BTRFS_INODE_DIRSYNC)
150 		new_fl |= S_DIRSYNC;
151 
152 	set_mask_bits(&inode->i_flags,
153 		      S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | S_DIRSYNC,
154 		      new_fl);
155 }
156 
157 /*
158  * Inherit flags from the parent inode.
159  *
160  * Currently only the compression flags and the cow flags are inherited.
161  */
162 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
163 {
164 	unsigned int flags;
165 
166 	if (!dir)
167 		return;
168 
169 	flags = BTRFS_I(dir)->flags;
170 
171 	if (flags & BTRFS_INODE_NOCOMPRESS) {
172 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
173 		BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
174 	} else if (flags & BTRFS_INODE_COMPRESS) {
175 		BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
176 		BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
177 	}
178 
179 	if (flags & BTRFS_INODE_NODATACOW) {
180 		BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
181 		if (S_ISREG(inode->i_mode))
182 			BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
183 	}
184 
185 	btrfs_update_iflags(inode);
186 }
187 
188 static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
189 {
190 	struct btrfs_inode *ip = BTRFS_I(file_inode(file));
191 	unsigned int flags = btrfs_flags_to_ioctl(ip->flags);
192 
193 	if (copy_to_user(arg, &flags, sizeof(flags)))
194 		return -EFAULT;
195 	return 0;
196 }
197 
198 static int check_flags(unsigned int flags)
199 {
200 	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
201 		      FS_NOATIME_FL | FS_NODUMP_FL | \
202 		      FS_SYNC_FL | FS_DIRSYNC_FL | \
203 		      FS_NOCOMP_FL | FS_COMPR_FL |
204 		      FS_NOCOW_FL))
205 		return -EOPNOTSUPP;
206 
207 	if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
208 		return -EINVAL;
209 
210 	return 0;
211 }
212 
213 static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
214 {
215 	struct inode *inode = file_inode(file);
216 	struct btrfs_inode *ip = BTRFS_I(inode);
217 	struct btrfs_root *root = ip->root;
218 	struct btrfs_trans_handle *trans;
219 	unsigned int flags, oldflags;
220 	int ret;
221 	u64 ip_oldflags;
222 	unsigned int i_oldflags;
223 	umode_t mode;
224 
225 	if (!inode_owner_or_capable(inode))
226 		return -EPERM;
227 
228 	if (btrfs_root_readonly(root))
229 		return -EROFS;
230 
231 	if (copy_from_user(&flags, arg, sizeof(flags)))
232 		return -EFAULT;
233 
234 	ret = check_flags(flags);
235 	if (ret)
236 		return ret;
237 
238 	ret = mnt_want_write_file(file);
239 	if (ret)
240 		return ret;
241 
242 	mutex_lock(&inode->i_mutex);
243 
244 	ip_oldflags = ip->flags;
245 	i_oldflags = inode->i_flags;
246 	mode = inode->i_mode;
247 
248 	flags = btrfs_mask_flags(inode->i_mode, flags);
249 	oldflags = btrfs_flags_to_ioctl(ip->flags);
250 	if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
251 		if (!capable(CAP_LINUX_IMMUTABLE)) {
252 			ret = -EPERM;
253 			goto out_unlock;
254 		}
255 	}
256 
257 	if (flags & FS_SYNC_FL)
258 		ip->flags |= BTRFS_INODE_SYNC;
259 	else
260 		ip->flags &= ~BTRFS_INODE_SYNC;
261 	if (flags & FS_IMMUTABLE_FL)
262 		ip->flags |= BTRFS_INODE_IMMUTABLE;
263 	else
264 		ip->flags &= ~BTRFS_INODE_IMMUTABLE;
265 	if (flags & FS_APPEND_FL)
266 		ip->flags |= BTRFS_INODE_APPEND;
267 	else
268 		ip->flags &= ~BTRFS_INODE_APPEND;
269 	if (flags & FS_NODUMP_FL)
270 		ip->flags |= BTRFS_INODE_NODUMP;
271 	else
272 		ip->flags &= ~BTRFS_INODE_NODUMP;
273 	if (flags & FS_NOATIME_FL)
274 		ip->flags |= BTRFS_INODE_NOATIME;
275 	else
276 		ip->flags &= ~BTRFS_INODE_NOATIME;
277 	if (flags & FS_DIRSYNC_FL)
278 		ip->flags |= BTRFS_INODE_DIRSYNC;
279 	else
280 		ip->flags &= ~BTRFS_INODE_DIRSYNC;
281 	if (flags & FS_NOCOW_FL) {
282 		if (S_ISREG(mode)) {
283 			/*
284 			 * It's safe to turn csums off here, no extents exist.
285 			 * Otherwise we want the flag to reflect the real COW
286 			 * status of the file and will not set it.
287 			 */
288 			if (inode->i_size == 0)
289 				ip->flags |= BTRFS_INODE_NODATACOW
290 					   | BTRFS_INODE_NODATASUM;
291 		} else {
292 			ip->flags |= BTRFS_INODE_NODATACOW;
293 		}
294 	} else {
295 		/*
296 		 * Revert back under same assuptions as above
297 		 */
298 		if (S_ISREG(mode)) {
299 			if (inode->i_size == 0)
300 				ip->flags &= ~(BTRFS_INODE_NODATACOW
301 				             | BTRFS_INODE_NODATASUM);
302 		} else {
303 			ip->flags &= ~BTRFS_INODE_NODATACOW;
304 		}
305 	}
306 
307 	/*
308 	 * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
309 	 * flag may be changed automatically if compression code won't make
310 	 * things smaller.
311 	 */
312 	if (flags & FS_NOCOMP_FL) {
313 		ip->flags &= ~BTRFS_INODE_COMPRESS;
314 		ip->flags |= BTRFS_INODE_NOCOMPRESS;
315 
316 		ret = btrfs_set_prop(inode, "btrfs.compression", NULL, 0, 0);
317 		if (ret && ret != -ENODATA)
318 			goto out_drop;
319 	} else if (flags & FS_COMPR_FL) {
320 		const char *comp;
321 
322 		ip->flags |= BTRFS_INODE_COMPRESS;
323 		ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
324 
325 		if (root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
326 			comp = "lzo";
327 		else
328 			comp = "zlib";
329 		ret = btrfs_set_prop(inode, "btrfs.compression",
330 				     comp, strlen(comp), 0);
331 		if (ret)
332 			goto out_drop;
333 
334 	} else {
335 		ret = btrfs_set_prop(inode, "btrfs.compression", NULL, 0, 0);
336 		if (ret && ret != -ENODATA)
337 			goto out_drop;
338 		ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
339 	}
340 
341 	trans = btrfs_start_transaction(root, 1);
342 	if (IS_ERR(trans)) {
343 		ret = PTR_ERR(trans);
344 		goto out_drop;
345 	}
346 
347 	btrfs_update_iflags(inode);
348 	inode_inc_iversion(inode);
349 	inode->i_ctime = CURRENT_TIME;
350 	ret = btrfs_update_inode(trans, root, inode);
351 
352 	btrfs_end_transaction(trans, root);
353  out_drop:
354 	if (ret) {
355 		ip->flags = ip_oldflags;
356 		inode->i_flags = i_oldflags;
357 	}
358 
359  out_unlock:
360 	mutex_unlock(&inode->i_mutex);
361 	mnt_drop_write_file(file);
362 	return ret;
363 }
364 
365 static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
366 {
367 	struct inode *inode = file_inode(file);
368 
369 	return put_user(inode->i_generation, arg);
370 }
371 
372 static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
373 {
374 	struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb);
375 	struct btrfs_device *device;
376 	struct request_queue *q;
377 	struct fstrim_range range;
378 	u64 minlen = ULLONG_MAX;
379 	u64 num_devices = 0;
380 	u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
381 	int ret;
382 
383 	if (!capable(CAP_SYS_ADMIN))
384 		return -EPERM;
385 
386 	rcu_read_lock();
387 	list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
388 				dev_list) {
389 		if (!device->bdev)
390 			continue;
391 		q = bdev_get_queue(device->bdev);
392 		if (blk_queue_discard(q)) {
393 			num_devices++;
394 			minlen = min((u64)q->limits.discard_granularity,
395 				     minlen);
396 		}
397 	}
398 	rcu_read_unlock();
399 
400 	if (!num_devices)
401 		return -EOPNOTSUPP;
402 	if (copy_from_user(&range, arg, sizeof(range)))
403 		return -EFAULT;
404 	if (range.start > total_bytes ||
405 	    range.len < fs_info->sb->s_blocksize)
406 		return -EINVAL;
407 
408 	range.len = min(range.len, total_bytes - range.start);
409 	range.minlen = max(range.minlen, minlen);
410 	ret = btrfs_trim_fs(fs_info->tree_root, &range);
411 	if (ret < 0)
412 		return ret;
413 
414 	if (copy_to_user(arg, &range, sizeof(range)))
415 		return -EFAULT;
416 
417 	return 0;
418 }
419 
420 int btrfs_is_empty_uuid(u8 *uuid)
421 {
422 	int i;
423 
424 	for (i = 0; i < BTRFS_UUID_SIZE; i++) {
425 		if (uuid[i])
426 			return 0;
427 	}
428 	return 1;
429 }
430 
431 static noinline int create_subvol(struct inode *dir,
432 				  struct dentry *dentry,
433 				  char *name, int namelen,
434 				  u64 *async_transid,
435 				  struct btrfs_qgroup_inherit *inherit)
436 {
437 	struct btrfs_trans_handle *trans;
438 	struct btrfs_key key;
439 	struct btrfs_root_item root_item;
440 	struct btrfs_inode_item *inode_item;
441 	struct extent_buffer *leaf;
442 	struct btrfs_root *root = BTRFS_I(dir)->root;
443 	struct btrfs_root *new_root;
444 	struct btrfs_block_rsv block_rsv;
445 	struct timespec cur_time = CURRENT_TIME;
446 	struct inode *inode;
447 	int ret;
448 	int err;
449 	u64 objectid;
450 	u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
451 	u64 index = 0;
452 	u64 qgroup_reserved;
453 	uuid_le new_uuid;
454 
455 	ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
456 	if (ret)
457 		return ret;
458 
459 	btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
460 	/*
461 	 * The same as the snapshot creation, please see the comment
462 	 * of create_snapshot().
463 	 */
464 	ret = btrfs_subvolume_reserve_metadata(root, &block_rsv,
465 					       8, &qgroup_reserved, false);
466 	if (ret)
467 		return ret;
468 
469 	trans = btrfs_start_transaction(root, 0);
470 	if (IS_ERR(trans)) {
471 		ret = PTR_ERR(trans);
472 		btrfs_subvolume_release_metadata(root, &block_rsv,
473 						 qgroup_reserved);
474 		return ret;
475 	}
476 	trans->block_rsv = &block_rsv;
477 	trans->bytes_reserved = block_rsv.size;
478 
479 	ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid, inherit);
480 	if (ret)
481 		goto fail;
482 
483 	leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
484 	if (IS_ERR(leaf)) {
485 		ret = PTR_ERR(leaf);
486 		goto fail;
487 	}
488 
489 	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
490 	btrfs_set_header_bytenr(leaf, leaf->start);
491 	btrfs_set_header_generation(leaf, trans->transid);
492 	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
493 	btrfs_set_header_owner(leaf, objectid);
494 
495 	write_extent_buffer(leaf, root->fs_info->fsid, btrfs_header_fsid(),
496 			    BTRFS_FSID_SIZE);
497 	write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
498 			    btrfs_header_chunk_tree_uuid(leaf),
499 			    BTRFS_UUID_SIZE);
500 	btrfs_mark_buffer_dirty(leaf);
501 
502 	memset(&root_item, 0, sizeof(root_item));
503 
504 	inode_item = &root_item.inode;
505 	btrfs_set_stack_inode_generation(inode_item, 1);
506 	btrfs_set_stack_inode_size(inode_item, 3);
507 	btrfs_set_stack_inode_nlink(inode_item, 1);
508 	btrfs_set_stack_inode_nbytes(inode_item, root->nodesize);
509 	btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
510 
511 	btrfs_set_root_flags(&root_item, 0);
512 	btrfs_set_root_limit(&root_item, 0);
513 	btrfs_set_stack_inode_flags(inode_item, BTRFS_INODE_ROOT_ITEM_INIT);
514 
515 	btrfs_set_root_bytenr(&root_item, leaf->start);
516 	btrfs_set_root_generation(&root_item, trans->transid);
517 	btrfs_set_root_level(&root_item, 0);
518 	btrfs_set_root_refs(&root_item, 1);
519 	btrfs_set_root_used(&root_item, leaf->len);
520 	btrfs_set_root_last_snapshot(&root_item, 0);
521 
522 	btrfs_set_root_generation_v2(&root_item,
523 			btrfs_root_generation(&root_item));
524 	uuid_le_gen(&new_uuid);
525 	memcpy(root_item.uuid, new_uuid.b, BTRFS_UUID_SIZE);
526 	btrfs_set_stack_timespec_sec(&root_item.otime, cur_time.tv_sec);
527 	btrfs_set_stack_timespec_nsec(&root_item.otime, cur_time.tv_nsec);
528 	root_item.ctime = root_item.otime;
529 	btrfs_set_root_ctransid(&root_item, trans->transid);
530 	btrfs_set_root_otransid(&root_item, trans->transid);
531 
532 	btrfs_tree_unlock(leaf);
533 	free_extent_buffer(leaf);
534 	leaf = NULL;
535 
536 	btrfs_set_root_dirid(&root_item, new_dirid);
537 
538 	key.objectid = objectid;
539 	key.offset = 0;
540 	key.type = BTRFS_ROOT_ITEM_KEY;
541 	ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
542 				&root_item);
543 	if (ret)
544 		goto fail;
545 
546 	key.offset = (u64)-1;
547 	new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
548 	if (IS_ERR(new_root)) {
549 		btrfs_abort_transaction(trans, root, PTR_ERR(new_root));
550 		ret = PTR_ERR(new_root);
551 		goto fail;
552 	}
553 
554 	btrfs_record_root_in_trans(trans, new_root);
555 
556 	ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
557 	if (ret) {
558 		/* We potentially lose an unused inode item here */
559 		btrfs_abort_transaction(trans, root, ret);
560 		goto fail;
561 	}
562 
563 	/*
564 	 * insert the directory item
565 	 */
566 	ret = btrfs_set_inode_index(dir, &index);
567 	if (ret) {
568 		btrfs_abort_transaction(trans, root, ret);
569 		goto fail;
570 	}
571 
572 	ret = btrfs_insert_dir_item(trans, root,
573 				    name, namelen, dir, &key,
574 				    BTRFS_FT_DIR, index);
575 	if (ret) {
576 		btrfs_abort_transaction(trans, root, ret);
577 		goto fail;
578 	}
579 
580 	btrfs_i_size_write(dir, dir->i_size + namelen * 2);
581 	ret = btrfs_update_inode(trans, root, dir);
582 	BUG_ON(ret);
583 
584 	ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
585 				 objectid, root->root_key.objectid,
586 				 btrfs_ino(dir), index, name, namelen);
587 	BUG_ON(ret);
588 
589 	ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root,
590 				  root_item.uuid, BTRFS_UUID_KEY_SUBVOL,
591 				  objectid);
592 	if (ret)
593 		btrfs_abort_transaction(trans, root, ret);
594 
595 fail:
596 	trans->block_rsv = NULL;
597 	trans->bytes_reserved = 0;
598 	btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
599 
600 	if (async_transid) {
601 		*async_transid = trans->transid;
602 		err = btrfs_commit_transaction_async(trans, root, 1);
603 		if (err)
604 			err = btrfs_commit_transaction(trans, root);
605 	} else {
606 		err = btrfs_commit_transaction(trans, root);
607 	}
608 	if (err && !ret)
609 		ret = err;
610 
611 	if (!ret) {
612 		inode = btrfs_lookup_dentry(dir, dentry);
613 		if (IS_ERR(inode))
614 			return PTR_ERR(inode);
615 		d_instantiate(dentry, inode);
616 	}
617 	return ret;
618 }
619 
620 static void btrfs_wait_nocow_write(struct btrfs_root *root)
621 {
622 	s64 writers;
623 	DEFINE_WAIT(wait);
624 
625 	do {
626 		prepare_to_wait(&root->subv_writers->wait, &wait,
627 				TASK_UNINTERRUPTIBLE);
628 
629 		writers = percpu_counter_sum(&root->subv_writers->counter);
630 		if (writers)
631 			schedule();
632 
633 		finish_wait(&root->subv_writers->wait, &wait);
634 	} while (writers);
635 }
636 
637 static int create_snapshot(struct btrfs_root *root, struct inode *dir,
638 			   struct dentry *dentry, char *name, int namelen,
639 			   u64 *async_transid, bool readonly,
640 			   struct btrfs_qgroup_inherit *inherit)
641 {
642 	struct inode *inode;
643 	struct btrfs_pending_snapshot *pending_snapshot;
644 	struct btrfs_trans_handle *trans;
645 	int ret;
646 
647 	if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state))
648 		return -EINVAL;
649 
650 	atomic_inc(&root->will_be_snapshoted);
651 	smp_mb__after_atomic();
652 	btrfs_wait_nocow_write(root);
653 
654 	ret = btrfs_start_delalloc_inodes(root, 0);
655 	if (ret)
656 		goto out;
657 
658 	btrfs_wait_ordered_extents(root, -1);
659 
660 	pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
661 	if (!pending_snapshot) {
662 		ret = -ENOMEM;
663 		goto out;
664 	}
665 
666 	btrfs_init_block_rsv(&pending_snapshot->block_rsv,
667 			     BTRFS_BLOCK_RSV_TEMP);
668 	/*
669 	 * 1 - parent dir inode
670 	 * 2 - dir entries
671 	 * 1 - root item
672 	 * 2 - root ref/backref
673 	 * 1 - root of snapshot
674 	 * 1 - UUID item
675 	 */
676 	ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
677 					&pending_snapshot->block_rsv, 8,
678 					&pending_snapshot->qgroup_reserved,
679 					false);
680 	if (ret)
681 		goto free;
682 
683 	pending_snapshot->dentry = dentry;
684 	pending_snapshot->root = root;
685 	pending_snapshot->readonly = readonly;
686 	pending_snapshot->dir = dir;
687 	pending_snapshot->inherit = inherit;
688 
689 	trans = btrfs_start_transaction(root, 0);
690 	if (IS_ERR(trans)) {
691 		ret = PTR_ERR(trans);
692 		goto fail;
693 	}
694 
695 	spin_lock(&root->fs_info->trans_lock);
696 	list_add(&pending_snapshot->list,
697 		 &trans->transaction->pending_snapshots);
698 	spin_unlock(&root->fs_info->trans_lock);
699 	if (async_transid) {
700 		*async_transid = trans->transid;
701 		ret = btrfs_commit_transaction_async(trans,
702 				     root->fs_info->extent_root, 1);
703 		if (ret)
704 			ret = btrfs_commit_transaction(trans, root);
705 	} else {
706 		ret = btrfs_commit_transaction(trans,
707 					       root->fs_info->extent_root);
708 	}
709 	if (ret)
710 		goto fail;
711 
712 	ret = pending_snapshot->error;
713 	if (ret)
714 		goto fail;
715 
716 	ret = btrfs_orphan_cleanup(pending_snapshot->snap);
717 	if (ret)
718 		goto fail;
719 
720 	/*
721 	 * If orphan cleanup did remove any orphans, it means the tree was
722 	 * modified and therefore the commit root is not the same as the
723 	 * current root anymore. This is a problem, because send uses the
724 	 * commit root and therefore can see inode items that don't exist
725 	 * in the current root anymore, and for example make calls to
726 	 * btrfs_iget, which will do tree lookups based on the current root
727 	 * and not on the commit root. Those lookups will fail, returning a
728 	 * -ESTALE error, and making send fail with that error. So make sure
729 	 * a send does not see any orphans we have just removed, and that it
730 	 * will see the same inodes regardless of whether a transaction
731 	 * commit happened before it started (meaning that the commit root
732 	 * will be the same as the current root) or not.
733 	 */
734 	if (readonly && pending_snapshot->snap->node !=
735 	    pending_snapshot->snap->commit_root) {
736 		trans = btrfs_join_transaction(pending_snapshot->snap);
737 		if (IS_ERR(trans) && PTR_ERR(trans) != -ENOENT) {
738 			ret = PTR_ERR(trans);
739 			goto fail;
740 		}
741 		if (!IS_ERR(trans)) {
742 			ret = btrfs_commit_transaction(trans,
743 						       pending_snapshot->snap);
744 			if (ret)
745 				goto fail;
746 		}
747 	}
748 
749 	inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
750 	if (IS_ERR(inode)) {
751 		ret = PTR_ERR(inode);
752 		goto fail;
753 	}
754 
755 	d_instantiate(dentry, inode);
756 	ret = 0;
757 fail:
758 	btrfs_subvolume_release_metadata(BTRFS_I(dir)->root,
759 					 &pending_snapshot->block_rsv,
760 					 pending_snapshot->qgroup_reserved);
761 free:
762 	kfree(pending_snapshot);
763 out:
764 	atomic_dec(&root->will_be_snapshoted);
765 	return ret;
766 }
767 
768 /*  copy of check_sticky in fs/namei.c()
769 * It's inline, so penalty for filesystems that don't use sticky bit is
770 * minimal.
771 */
772 static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
773 {
774 	kuid_t fsuid = current_fsuid();
775 
776 	if (!(dir->i_mode & S_ISVTX))
777 		return 0;
778 	if (uid_eq(inode->i_uid, fsuid))
779 		return 0;
780 	if (uid_eq(dir->i_uid, fsuid))
781 		return 0;
782 	return !capable(CAP_FOWNER);
783 }
784 
785 /*  copy of may_delete in fs/namei.c()
786  *	Check whether we can remove a link victim from directory dir, check
787  *  whether the type of victim is right.
788  *  1. We can't do it if dir is read-only (done in permission())
789  *  2. We should have write and exec permissions on dir
790  *  3. We can't remove anything from append-only dir
791  *  4. We can't do anything with immutable dir (done in permission())
792  *  5. If the sticky bit on dir is set we should either
793  *	a. be owner of dir, or
794  *	b. be owner of victim, or
795  *	c. have CAP_FOWNER capability
796  *  6. If the victim is append-only or immutable we can't do antyhing with
797  *     links pointing to it.
798  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
799  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
800  *  9. We can't remove a root or mountpoint.
801  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
802  *     nfs_async_unlink().
803  */
804 
805 static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
806 {
807 	int error;
808 
809 	if (!victim->d_inode)
810 		return -ENOENT;
811 
812 	BUG_ON(victim->d_parent->d_inode != dir);
813 	audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
814 
815 	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
816 	if (error)
817 		return error;
818 	if (IS_APPEND(dir))
819 		return -EPERM;
820 	if (btrfs_check_sticky(dir, victim->d_inode)||
821 		IS_APPEND(victim->d_inode)||
822 	    IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
823 		return -EPERM;
824 	if (isdir) {
825 		if (!S_ISDIR(victim->d_inode->i_mode))
826 			return -ENOTDIR;
827 		if (IS_ROOT(victim))
828 			return -EBUSY;
829 	} else if (S_ISDIR(victim->d_inode->i_mode))
830 		return -EISDIR;
831 	if (IS_DEADDIR(dir))
832 		return -ENOENT;
833 	if (victim->d_flags & DCACHE_NFSFS_RENAMED)
834 		return -EBUSY;
835 	return 0;
836 }
837 
838 /* copy of may_create in fs/namei.c() */
839 static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
840 {
841 	if (child->d_inode)
842 		return -EEXIST;
843 	if (IS_DEADDIR(dir))
844 		return -ENOENT;
845 	return inode_permission(dir, MAY_WRITE | MAY_EXEC);
846 }
847 
848 /*
849  * Create a new subvolume below @parent.  This is largely modeled after
850  * sys_mkdirat and vfs_mkdir, but we only do a single component lookup
851  * inside this filesystem so it's quite a bit simpler.
852  */
853 static noinline int btrfs_mksubvol(struct path *parent,
854 				   char *name, int namelen,
855 				   struct btrfs_root *snap_src,
856 				   u64 *async_transid, bool readonly,
857 				   struct btrfs_qgroup_inherit *inherit)
858 {
859 	struct inode *dir  = parent->dentry->d_inode;
860 	struct dentry *dentry;
861 	int error;
862 
863 	error = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT);
864 	if (error == -EINTR)
865 		return error;
866 
867 	dentry = lookup_one_len(name, parent->dentry, namelen);
868 	error = PTR_ERR(dentry);
869 	if (IS_ERR(dentry))
870 		goto out_unlock;
871 
872 	error = -EEXIST;
873 	if (dentry->d_inode)
874 		goto out_dput;
875 
876 	error = btrfs_may_create(dir, dentry);
877 	if (error)
878 		goto out_dput;
879 
880 	/*
881 	 * even if this name doesn't exist, we may get hash collisions.
882 	 * check for them now when we can safely fail
883 	 */
884 	error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
885 					       dir->i_ino, name,
886 					       namelen);
887 	if (error)
888 		goto out_dput;
889 
890 	down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
891 
892 	if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
893 		goto out_up_read;
894 
895 	if (snap_src) {
896 		error = create_snapshot(snap_src, dir, dentry, name, namelen,
897 					async_transid, readonly, inherit);
898 	} else {
899 		error = create_subvol(dir, dentry, name, namelen,
900 				      async_transid, inherit);
901 	}
902 	if (!error)
903 		fsnotify_mkdir(dir, dentry);
904 out_up_read:
905 	up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
906 out_dput:
907 	dput(dentry);
908 out_unlock:
909 	mutex_unlock(&dir->i_mutex);
910 	return error;
911 }
912 
913 /*
914  * When we're defragging a range, we don't want to kick it off again
915  * if it is really just waiting for delalloc to send it down.
916  * If we find a nice big extent or delalloc range for the bytes in the
917  * file you want to defrag, we return 0 to let you know to skip this
918  * part of the file
919  */
920 static int check_defrag_in_cache(struct inode *inode, u64 offset, u32 thresh)
921 {
922 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
923 	struct extent_map *em = NULL;
924 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
925 	u64 end;
926 
927 	read_lock(&em_tree->lock);
928 	em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
929 	read_unlock(&em_tree->lock);
930 
931 	if (em) {
932 		end = extent_map_end(em);
933 		free_extent_map(em);
934 		if (end - offset > thresh)
935 			return 0;
936 	}
937 	/* if we already have a nice delalloc here, just stop */
938 	thresh /= 2;
939 	end = count_range_bits(io_tree, &offset, offset + thresh,
940 			       thresh, EXTENT_DELALLOC, 1);
941 	if (end >= thresh)
942 		return 0;
943 	return 1;
944 }
945 
946 /*
947  * helper function to walk through a file and find extents
948  * newer than a specific transid, and smaller than thresh.
949  *
950  * This is used by the defragging code to find new and small
951  * extents
952  */
953 static int find_new_extents(struct btrfs_root *root,
954 			    struct inode *inode, u64 newer_than,
955 			    u64 *off, u32 thresh)
956 {
957 	struct btrfs_path *path;
958 	struct btrfs_key min_key;
959 	struct extent_buffer *leaf;
960 	struct btrfs_file_extent_item *extent;
961 	int type;
962 	int ret;
963 	u64 ino = btrfs_ino(inode);
964 
965 	path = btrfs_alloc_path();
966 	if (!path)
967 		return -ENOMEM;
968 
969 	min_key.objectid = ino;
970 	min_key.type = BTRFS_EXTENT_DATA_KEY;
971 	min_key.offset = *off;
972 
973 	while (1) {
974 		ret = btrfs_search_forward(root, &min_key, path, newer_than);
975 		if (ret != 0)
976 			goto none;
977 process_slot:
978 		if (min_key.objectid != ino)
979 			goto none;
980 		if (min_key.type != BTRFS_EXTENT_DATA_KEY)
981 			goto none;
982 
983 		leaf = path->nodes[0];
984 		extent = btrfs_item_ptr(leaf, path->slots[0],
985 					struct btrfs_file_extent_item);
986 
987 		type = btrfs_file_extent_type(leaf, extent);
988 		if (type == BTRFS_FILE_EXTENT_REG &&
989 		    btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
990 		    check_defrag_in_cache(inode, min_key.offset, thresh)) {
991 			*off = min_key.offset;
992 			btrfs_free_path(path);
993 			return 0;
994 		}
995 
996 		path->slots[0]++;
997 		if (path->slots[0] < btrfs_header_nritems(leaf)) {
998 			btrfs_item_key_to_cpu(leaf, &min_key, path->slots[0]);
999 			goto process_slot;
1000 		}
1001 
1002 		if (min_key.offset == (u64)-1)
1003 			goto none;
1004 
1005 		min_key.offset++;
1006 		btrfs_release_path(path);
1007 	}
1008 none:
1009 	btrfs_free_path(path);
1010 	return -ENOENT;
1011 }
1012 
1013 static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
1014 {
1015 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
1016 	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
1017 	struct extent_map *em;
1018 	u64 len = PAGE_CACHE_SIZE;
1019 
1020 	/*
1021 	 * hopefully we have this extent in the tree already, try without
1022 	 * the full extent lock
1023 	 */
1024 	read_lock(&em_tree->lock);
1025 	em = lookup_extent_mapping(em_tree, start, len);
1026 	read_unlock(&em_tree->lock);
1027 
1028 	if (!em) {
1029 		struct extent_state *cached = NULL;
1030 		u64 end = start + len - 1;
1031 
1032 		/* get the big lock and read metadata off disk */
1033 		lock_extent_bits(io_tree, start, end, 0, &cached);
1034 		em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
1035 		unlock_extent_cached(io_tree, start, end, &cached, GFP_NOFS);
1036 
1037 		if (IS_ERR(em))
1038 			return NULL;
1039 	}
1040 
1041 	return em;
1042 }
1043 
1044 static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
1045 {
1046 	struct extent_map *next;
1047 	bool ret = true;
1048 
1049 	/* this is the last extent */
1050 	if (em->start + em->len >= i_size_read(inode))
1051 		return false;
1052 
1053 	next = defrag_lookup_extent(inode, em->start + em->len);
1054 	if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE)
1055 		ret = false;
1056 	else if ((em->block_start + em->block_len == next->block_start) &&
1057 		 (em->block_len > 128 * 1024 && next->block_len > 128 * 1024))
1058 		ret = false;
1059 
1060 	free_extent_map(next);
1061 	return ret;
1062 }
1063 
1064 static int should_defrag_range(struct inode *inode, u64 start, u32 thresh,
1065 			       u64 *last_len, u64 *skip, u64 *defrag_end,
1066 			       int compress)
1067 {
1068 	struct extent_map *em;
1069 	int ret = 1;
1070 	bool next_mergeable = true;
1071 
1072 	/*
1073 	 * make sure that once we start defragging an extent, we keep on
1074 	 * defragging it
1075 	 */
1076 	if (start < *defrag_end)
1077 		return 1;
1078 
1079 	*skip = 0;
1080 
1081 	em = defrag_lookup_extent(inode, start);
1082 	if (!em)
1083 		return 0;
1084 
1085 	/* this will cover holes, and inline extents */
1086 	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
1087 		ret = 0;
1088 		goto out;
1089 	}
1090 
1091 	next_mergeable = defrag_check_next_extent(inode, em);
1092 	/*
1093 	 * we hit a real extent, if it is big or the next extent is not a
1094 	 * real extent, don't bother defragging it
1095 	 */
1096 	if (!compress && (*last_len == 0 || *last_len >= thresh) &&
1097 	    (em->len >= thresh || !next_mergeable))
1098 		ret = 0;
1099 out:
1100 	/*
1101 	 * last_len ends up being a counter of how many bytes we've defragged.
1102 	 * every time we choose not to defrag an extent, we reset *last_len
1103 	 * so that the next tiny extent will force a defrag.
1104 	 *
1105 	 * The end result of this is that tiny extents before a single big
1106 	 * extent will force at least part of that big extent to be defragged.
1107 	 */
1108 	if (ret) {
1109 		*defrag_end = extent_map_end(em);
1110 	} else {
1111 		*last_len = 0;
1112 		*skip = extent_map_end(em);
1113 		*defrag_end = 0;
1114 	}
1115 
1116 	free_extent_map(em);
1117 	return ret;
1118 }
1119 
1120 /*
1121  * it doesn't do much good to defrag one or two pages
1122  * at a time.  This pulls in a nice chunk of pages
1123  * to COW and defrag.
1124  *
1125  * It also makes sure the delalloc code has enough
1126  * dirty data to avoid making new small extents as part
1127  * of the defrag
1128  *
1129  * It's a good idea to start RA on this range
1130  * before calling this.
1131  */
1132 static int cluster_pages_for_defrag(struct inode *inode,
1133 				    struct page **pages,
1134 				    unsigned long start_index,
1135 				    unsigned long num_pages)
1136 {
1137 	unsigned long file_end;
1138 	u64 isize = i_size_read(inode);
1139 	u64 page_start;
1140 	u64 page_end;
1141 	u64 page_cnt;
1142 	int ret;
1143 	int i;
1144 	int i_done;
1145 	struct btrfs_ordered_extent *ordered;
1146 	struct extent_state *cached_state = NULL;
1147 	struct extent_io_tree *tree;
1148 	gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
1149 
1150 	file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
1151 	if (!isize || start_index > file_end)
1152 		return 0;
1153 
1154 	page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1);
1155 
1156 	ret = btrfs_delalloc_reserve_space(inode,
1157 					   page_cnt << PAGE_CACHE_SHIFT);
1158 	if (ret)
1159 		return ret;
1160 	i_done = 0;
1161 	tree = &BTRFS_I(inode)->io_tree;
1162 
1163 	/* step one, lock all the pages */
1164 	for (i = 0; i < page_cnt; i++) {
1165 		struct page *page;
1166 again:
1167 		page = find_or_create_page(inode->i_mapping,
1168 					   start_index + i, mask);
1169 		if (!page)
1170 			break;
1171 
1172 		page_start = page_offset(page);
1173 		page_end = page_start + PAGE_CACHE_SIZE - 1;
1174 		while (1) {
1175 			lock_extent_bits(tree, page_start, page_end,
1176 					 0, &cached_state);
1177 			ordered = btrfs_lookup_ordered_extent(inode,
1178 							      page_start);
1179 			unlock_extent_cached(tree, page_start, page_end,
1180 					     &cached_state, GFP_NOFS);
1181 			if (!ordered)
1182 				break;
1183 
1184 			unlock_page(page);
1185 			btrfs_start_ordered_extent(inode, ordered, 1);
1186 			btrfs_put_ordered_extent(ordered);
1187 			lock_page(page);
1188 			/*
1189 			 * we unlocked the page above, so we need check if
1190 			 * it was released or not.
1191 			 */
1192 			if (page->mapping != inode->i_mapping) {
1193 				unlock_page(page);
1194 				page_cache_release(page);
1195 				goto again;
1196 			}
1197 		}
1198 
1199 		if (!PageUptodate(page)) {
1200 			btrfs_readpage(NULL, page);
1201 			lock_page(page);
1202 			if (!PageUptodate(page)) {
1203 				unlock_page(page);
1204 				page_cache_release(page);
1205 				ret = -EIO;
1206 				break;
1207 			}
1208 		}
1209 
1210 		if (page->mapping != inode->i_mapping) {
1211 			unlock_page(page);
1212 			page_cache_release(page);
1213 			goto again;
1214 		}
1215 
1216 		pages[i] = page;
1217 		i_done++;
1218 	}
1219 	if (!i_done || ret)
1220 		goto out;
1221 
1222 	if (!(inode->i_sb->s_flags & MS_ACTIVE))
1223 		goto out;
1224 
1225 	/*
1226 	 * so now we have a nice long stream of locked
1227 	 * and up to date pages, lets wait on them
1228 	 */
1229 	for (i = 0; i < i_done; i++)
1230 		wait_on_page_writeback(pages[i]);
1231 
1232 	page_start = page_offset(pages[0]);
1233 	page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;
1234 
1235 	lock_extent_bits(&BTRFS_I(inode)->io_tree,
1236 			 page_start, page_end - 1, 0, &cached_state);
1237 	clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
1238 			  page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
1239 			  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
1240 			  &cached_state, GFP_NOFS);
1241 
1242 	if (i_done != page_cnt) {
1243 		spin_lock(&BTRFS_I(inode)->lock);
1244 		BTRFS_I(inode)->outstanding_extents++;
1245 		spin_unlock(&BTRFS_I(inode)->lock);
1246 		btrfs_delalloc_release_space(inode,
1247 				     (page_cnt - i_done) << PAGE_CACHE_SHIFT);
1248 	}
1249 
1250 
1251 	set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
1252 			  &cached_state, GFP_NOFS);
1253 
1254 	unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1255 			     page_start, page_end - 1, &cached_state,
1256 			     GFP_NOFS);
1257 
1258 	for (i = 0; i < i_done; i++) {
1259 		clear_page_dirty_for_io(pages[i]);
1260 		ClearPageChecked(pages[i]);
1261 		set_page_extent_mapped(pages[i]);
1262 		set_page_dirty(pages[i]);
1263 		unlock_page(pages[i]);
1264 		page_cache_release(pages[i]);
1265 	}
1266 	return i_done;
1267 out:
1268 	for (i = 0; i < i_done; i++) {
1269 		unlock_page(pages[i]);
1270 		page_cache_release(pages[i]);
1271 	}
1272 	btrfs_delalloc_release_space(inode, page_cnt << PAGE_CACHE_SHIFT);
1273 	return ret;
1274 
1275 }
1276 
1277 int btrfs_defrag_file(struct inode *inode, struct file *file,
1278 		      struct btrfs_ioctl_defrag_range_args *range,
1279 		      u64 newer_than, unsigned long max_to_defrag)
1280 {
1281 	struct btrfs_root *root = BTRFS_I(inode)->root;
1282 	struct file_ra_state *ra = NULL;
1283 	unsigned long last_index;
1284 	u64 isize = i_size_read(inode);
1285 	u64 last_len = 0;
1286 	u64 skip = 0;
1287 	u64 defrag_end = 0;
1288 	u64 newer_off = range->start;
1289 	unsigned long i;
1290 	unsigned long ra_index = 0;
1291 	int ret;
1292 	int defrag_count = 0;
1293 	int compress_type = BTRFS_COMPRESS_ZLIB;
1294 	u32 extent_thresh = range->extent_thresh;
1295 	unsigned long max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT;
1296 	unsigned long cluster = max_cluster;
1297 	u64 new_align = ~((u64)128 * 1024 - 1);
1298 	struct page **pages = NULL;
1299 
1300 	if (isize == 0)
1301 		return 0;
1302 
1303 	if (range->start >= isize)
1304 		return -EINVAL;
1305 
1306 	if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
1307 		if (range->compress_type > BTRFS_COMPRESS_TYPES)
1308 			return -EINVAL;
1309 		if (range->compress_type)
1310 			compress_type = range->compress_type;
1311 	}
1312 
1313 	if (extent_thresh == 0)
1314 		extent_thresh = 256 * 1024;
1315 
1316 	/*
1317 	 * if we were not given a file, allocate a readahead
1318 	 * context
1319 	 */
1320 	if (!file) {
1321 		ra = kzalloc(sizeof(*ra), GFP_NOFS);
1322 		if (!ra)
1323 			return -ENOMEM;
1324 		file_ra_state_init(ra, inode->i_mapping);
1325 	} else {
1326 		ra = &file->f_ra;
1327 	}
1328 
1329 	pages = kmalloc_array(max_cluster, sizeof(struct page *),
1330 			GFP_NOFS);
1331 	if (!pages) {
1332 		ret = -ENOMEM;
1333 		goto out_ra;
1334 	}
1335 
1336 	/* find the last page to defrag */
1337 	if (range->start + range->len > range->start) {
1338 		last_index = min_t(u64, isize - 1,
1339 			 range->start + range->len - 1) >> PAGE_CACHE_SHIFT;
1340 	} else {
1341 		last_index = (isize - 1) >> PAGE_CACHE_SHIFT;
1342 	}
1343 
1344 	if (newer_than) {
1345 		ret = find_new_extents(root, inode, newer_than,
1346 				       &newer_off, 64 * 1024);
1347 		if (!ret) {
1348 			range->start = newer_off;
1349 			/*
1350 			 * we always align our defrag to help keep
1351 			 * the extents in the file evenly spaced
1352 			 */
1353 			i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
1354 		} else
1355 			goto out_ra;
1356 	} else {
1357 		i = range->start >> PAGE_CACHE_SHIFT;
1358 	}
1359 	if (!max_to_defrag)
1360 		max_to_defrag = last_index + 1;
1361 
1362 	/*
1363 	 * make writeback starts from i, so the defrag range can be
1364 	 * written sequentially.
1365 	 */
1366 	if (i < inode->i_mapping->writeback_index)
1367 		inode->i_mapping->writeback_index = i;
1368 
1369 	while (i <= last_index && defrag_count < max_to_defrag &&
1370 	       (i < DIV_ROUND_UP(i_size_read(inode), PAGE_CACHE_SIZE))) {
1371 		/*
1372 		 * make sure we stop running if someone unmounts
1373 		 * the FS
1374 		 */
1375 		if (!(inode->i_sb->s_flags & MS_ACTIVE))
1376 			break;
1377 
1378 		if (btrfs_defrag_cancelled(root->fs_info)) {
1379 			printk(KERN_DEBUG "BTRFS: defrag_file cancelled\n");
1380 			ret = -EAGAIN;
1381 			break;
1382 		}
1383 
1384 		if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
1385 					 extent_thresh, &last_len, &skip,
1386 					 &defrag_end, range->flags &
1387 					 BTRFS_DEFRAG_RANGE_COMPRESS)) {
1388 			unsigned long next;
1389 			/*
1390 			 * the should_defrag function tells us how much to skip
1391 			 * bump our counter by the suggested amount
1392 			 */
1393 			next = DIV_ROUND_UP(skip, PAGE_CACHE_SIZE);
1394 			i = max(i + 1, next);
1395 			continue;
1396 		}
1397 
1398 		if (!newer_than) {
1399 			cluster = (PAGE_CACHE_ALIGN(defrag_end) >>
1400 				   PAGE_CACHE_SHIFT) - i;
1401 			cluster = min(cluster, max_cluster);
1402 		} else {
1403 			cluster = max_cluster;
1404 		}
1405 
1406 		if (i + cluster > ra_index) {
1407 			ra_index = max(i, ra_index);
1408 			btrfs_force_ra(inode->i_mapping, ra, file, ra_index,
1409 				       cluster);
1410 			ra_index += max_cluster;
1411 		}
1412 
1413 		mutex_lock(&inode->i_mutex);
1414 		if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
1415 			BTRFS_I(inode)->force_compress = compress_type;
1416 		ret = cluster_pages_for_defrag(inode, pages, i, cluster);
1417 		if (ret < 0) {
1418 			mutex_unlock(&inode->i_mutex);
1419 			goto out_ra;
1420 		}
1421 
1422 		defrag_count += ret;
1423 		balance_dirty_pages_ratelimited(inode->i_mapping);
1424 		mutex_unlock(&inode->i_mutex);
1425 
1426 		if (newer_than) {
1427 			if (newer_off == (u64)-1)
1428 				break;
1429 
1430 			if (ret > 0)
1431 				i += ret;
1432 
1433 			newer_off = max(newer_off + 1,
1434 					(u64)i << PAGE_CACHE_SHIFT);
1435 
1436 			ret = find_new_extents(root, inode,
1437 					       newer_than, &newer_off,
1438 					       64 * 1024);
1439 			if (!ret) {
1440 				range->start = newer_off;
1441 				i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
1442 			} else {
1443 				break;
1444 			}
1445 		} else {
1446 			if (ret > 0) {
1447 				i += ret;
1448 				last_len += ret << PAGE_CACHE_SHIFT;
1449 			} else {
1450 				i++;
1451 				last_len = 0;
1452 			}
1453 		}
1454 	}
1455 
1456 	if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO)) {
1457 		filemap_flush(inode->i_mapping);
1458 		if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
1459 			     &BTRFS_I(inode)->runtime_flags))
1460 			filemap_flush(inode->i_mapping);
1461 	}
1462 
1463 	if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
1464 		/* the filemap_flush will queue IO into the worker threads, but
1465 		 * we have to make sure the IO is actually started and that
1466 		 * ordered extents get created before we return
1467 		 */
1468 		atomic_inc(&root->fs_info->async_submit_draining);
1469 		while (atomic_read(&root->fs_info->nr_async_submits) ||
1470 		      atomic_read(&root->fs_info->async_delalloc_pages)) {
1471 			wait_event(root->fs_info->async_submit_wait,
1472 			   (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
1473 			    atomic_read(&root->fs_info->async_delalloc_pages) == 0));
1474 		}
1475 		atomic_dec(&root->fs_info->async_submit_draining);
1476 	}
1477 
1478 	if (range->compress_type == BTRFS_COMPRESS_LZO) {
1479 		btrfs_set_fs_incompat(root->fs_info, COMPRESS_LZO);
1480 	}
1481 
1482 	ret = defrag_count;
1483 
1484 out_ra:
1485 	if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
1486 		mutex_lock(&inode->i_mutex);
1487 		BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
1488 		mutex_unlock(&inode->i_mutex);
1489 	}
1490 	if (!file)
1491 		kfree(ra);
1492 	kfree(pages);
1493 	return ret;
1494 }
1495 
1496 static noinline int btrfs_ioctl_resize(struct file *file,
1497 					void __user *arg)
1498 {
1499 	u64 new_size;
1500 	u64 old_size;
1501 	u64 devid = 1;
1502 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
1503 	struct btrfs_ioctl_vol_args *vol_args;
1504 	struct btrfs_trans_handle *trans;
1505 	struct btrfs_device *device = NULL;
1506 	char *sizestr;
1507 	char *retptr;
1508 	char *devstr = NULL;
1509 	int ret = 0;
1510 	int mod = 0;
1511 
1512 	if (!capable(CAP_SYS_ADMIN))
1513 		return -EPERM;
1514 
1515 	ret = mnt_want_write_file(file);
1516 	if (ret)
1517 		return ret;
1518 
1519 	if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
1520 			1)) {
1521 		mnt_drop_write_file(file);
1522 		return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
1523 	}
1524 
1525 	mutex_lock(&root->fs_info->volume_mutex);
1526 	vol_args = memdup_user(arg, sizeof(*vol_args));
1527 	if (IS_ERR(vol_args)) {
1528 		ret = PTR_ERR(vol_args);
1529 		goto out;
1530 	}
1531 
1532 	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
1533 
1534 	sizestr = vol_args->name;
1535 	devstr = strchr(sizestr, ':');
1536 	if (devstr) {
1537 		sizestr = devstr + 1;
1538 		*devstr = '\0';
1539 		devstr = vol_args->name;
1540 		ret = kstrtoull(devstr, 10, &devid);
1541 		if (ret)
1542 			goto out_free;
1543 		if (!devid) {
1544 			ret = -EINVAL;
1545 			goto out_free;
1546 		}
1547 		btrfs_info(root->fs_info, "resizing devid %llu", devid);
1548 	}
1549 
1550 	device = btrfs_find_device(root->fs_info, devid, NULL, NULL);
1551 	if (!device) {
1552 		btrfs_info(root->fs_info, "resizer unable to find device %llu",
1553 		       devid);
1554 		ret = -ENODEV;
1555 		goto out_free;
1556 	}
1557 
1558 	if (!device->writeable) {
1559 		btrfs_info(root->fs_info,
1560 			   "resizer unable to apply on readonly device %llu",
1561 		       devid);
1562 		ret = -EPERM;
1563 		goto out_free;
1564 	}
1565 
1566 	if (!strcmp(sizestr, "max"))
1567 		new_size = device->bdev->bd_inode->i_size;
1568 	else {
1569 		if (sizestr[0] == '-') {
1570 			mod = -1;
1571 			sizestr++;
1572 		} else if (sizestr[0] == '+') {
1573 			mod = 1;
1574 			sizestr++;
1575 		}
1576 		new_size = memparse(sizestr, &retptr);
1577 		if (*retptr != '\0' || new_size == 0) {
1578 			ret = -EINVAL;
1579 			goto out_free;
1580 		}
1581 	}
1582 
1583 	if (device->is_tgtdev_for_dev_replace) {
1584 		ret = -EPERM;
1585 		goto out_free;
1586 	}
1587 
1588 	old_size = btrfs_device_get_total_bytes(device);
1589 
1590 	if (mod < 0) {
1591 		if (new_size > old_size) {
1592 			ret = -EINVAL;
1593 			goto out_free;
1594 		}
1595 		new_size = old_size - new_size;
1596 	} else if (mod > 0) {
1597 		if (new_size > ULLONG_MAX - old_size) {
1598 			ret = -ERANGE;
1599 			goto out_free;
1600 		}
1601 		new_size = old_size + new_size;
1602 	}
1603 
1604 	if (new_size < 256 * 1024 * 1024) {
1605 		ret = -EINVAL;
1606 		goto out_free;
1607 	}
1608 	if (new_size > device->bdev->bd_inode->i_size) {
1609 		ret = -EFBIG;
1610 		goto out_free;
1611 	}
1612 
1613 	do_div(new_size, root->sectorsize);
1614 	new_size *= root->sectorsize;
1615 
1616 	printk_in_rcu(KERN_INFO "BTRFS: new size for %s is %llu\n",
1617 		      rcu_str_deref(device->name), new_size);
1618 
1619 	if (new_size > old_size) {
1620 		trans = btrfs_start_transaction(root, 0);
1621 		if (IS_ERR(trans)) {
1622 			ret = PTR_ERR(trans);
1623 			goto out_free;
1624 		}
1625 		ret = btrfs_grow_device(trans, device, new_size);
1626 		btrfs_commit_transaction(trans, root);
1627 	} else if (new_size < old_size) {
1628 		ret = btrfs_shrink_device(device, new_size);
1629 	} /* equal, nothing need to do */
1630 
1631 out_free:
1632 	kfree(vol_args);
1633 out:
1634 	mutex_unlock(&root->fs_info->volume_mutex);
1635 	atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
1636 	mnt_drop_write_file(file);
1637 	return ret;
1638 }
1639 
1640 static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
1641 				char *name, unsigned long fd, int subvol,
1642 				u64 *transid, bool readonly,
1643 				struct btrfs_qgroup_inherit *inherit)
1644 {
1645 	int namelen;
1646 	int ret = 0;
1647 
1648 	ret = mnt_want_write_file(file);
1649 	if (ret)
1650 		goto out;
1651 
1652 	namelen = strlen(name);
1653 	if (strchr(name, '/')) {
1654 		ret = -EINVAL;
1655 		goto out_drop_write;
1656 	}
1657 
1658 	if (name[0] == '.' &&
1659 	   (namelen == 1 || (name[1] == '.' && namelen == 2))) {
1660 		ret = -EEXIST;
1661 		goto out_drop_write;
1662 	}
1663 
1664 	if (subvol) {
1665 		ret = btrfs_mksubvol(&file->f_path, name, namelen,
1666 				     NULL, transid, readonly, inherit);
1667 	} else {
1668 		struct fd src = fdget(fd);
1669 		struct inode *src_inode;
1670 		if (!src.file) {
1671 			ret = -EINVAL;
1672 			goto out_drop_write;
1673 		}
1674 
1675 		src_inode = file_inode(src.file);
1676 		if (src_inode->i_sb != file_inode(file)->i_sb) {
1677 			btrfs_info(BTRFS_I(src_inode)->root->fs_info,
1678 				   "Snapshot src from another FS");
1679 			ret = -EXDEV;
1680 		} else if (!inode_owner_or_capable(src_inode)) {
1681 			/*
1682 			 * Subvolume creation is not restricted, but snapshots
1683 			 * are limited to own subvolumes only
1684 			 */
1685 			ret = -EPERM;
1686 		} else {
1687 			ret = btrfs_mksubvol(&file->f_path, name, namelen,
1688 					     BTRFS_I(src_inode)->root,
1689 					     transid, readonly, inherit);
1690 		}
1691 		fdput(src);
1692 	}
1693 out_drop_write:
1694 	mnt_drop_write_file(file);
1695 out:
1696 	return ret;
1697 }
1698 
1699 static noinline int btrfs_ioctl_snap_create(struct file *file,
1700 					    void __user *arg, int subvol)
1701 {
1702 	struct btrfs_ioctl_vol_args *vol_args;
1703 	int ret;
1704 
1705 	vol_args = memdup_user(arg, sizeof(*vol_args));
1706 	if (IS_ERR(vol_args))
1707 		return PTR_ERR(vol_args);
1708 	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
1709 
1710 	ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
1711 					      vol_args->fd, subvol,
1712 					      NULL, false, NULL);
1713 
1714 	kfree(vol_args);
1715 	return ret;
1716 }
1717 
1718 static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
1719 					       void __user *arg, int subvol)
1720 {
1721 	struct btrfs_ioctl_vol_args_v2 *vol_args;
1722 	int ret;
1723 	u64 transid = 0;
1724 	u64 *ptr = NULL;
1725 	bool readonly = false;
1726 	struct btrfs_qgroup_inherit *inherit = NULL;
1727 
1728 	vol_args = memdup_user(arg, sizeof(*vol_args));
1729 	if (IS_ERR(vol_args))
1730 		return PTR_ERR(vol_args);
1731 	vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
1732 
1733 	if (vol_args->flags &
1734 	    ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY |
1735 	      BTRFS_SUBVOL_QGROUP_INHERIT)) {
1736 		ret = -EOPNOTSUPP;
1737 		goto free_args;
1738 	}
1739 
1740 	if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC)
1741 		ptr = &transid;
1742 	if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
1743 		readonly = true;
1744 	if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
1745 		if (vol_args->size > PAGE_CACHE_SIZE) {
1746 			ret = -EINVAL;
1747 			goto free_args;
1748 		}
1749 		inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size);
1750 		if (IS_ERR(inherit)) {
1751 			ret = PTR_ERR(inherit);
1752 			goto free_args;
1753 		}
1754 	}
1755 
1756 	ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
1757 					      vol_args->fd, subvol, ptr,
1758 					      readonly, inherit);
1759 	if (ret)
1760 		goto free_inherit;
1761 
1762 	if (ptr && copy_to_user(arg +
1763 				offsetof(struct btrfs_ioctl_vol_args_v2,
1764 					transid),
1765 				ptr, sizeof(*ptr)))
1766 		ret = -EFAULT;
1767 
1768 free_inherit:
1769 	kfree(inherit);
1770 free_args:
1771 	kfree(vol_args);
1772 	return ret;
1773 }
1774 
1775 static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
1776 						void __user *arg)
1777 {
1778 	struct inode *inode = file_inode(file);
1779 	struct btrfs_root *root = BTRFS_I(inode)->root;
1780 	int ret = 0;
1781 	u64 flags = 0;
1782 
1783 	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
1784 		return -EINVAL;
1785 
1786 	down_read(&root->fs_info->subvol_sem);
1787 	if (btrfs_root_readonly(root))
1788 		flags |= BTRFS_SUBVOL_RDONLY;
1789 	up_read(&root->fs_info->subvol_sem);
1790 
1791 	if (copy_to_user(arg, &flags, sizeof(flags)))
1792 		ret = -EFAULT;
1793 
1794 	return ret;
1795 }
1796 
1797 static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
1798 					      void __user *arg)
1799 {
1800 	struct inode *inode = file_inode(file);
1801 	struct btrfs_root *root = BTRFS_I(inode)->root;
1802 	struct btrfs_trans_handle *trans;
1803 	u64 root_flags;
1804 	u64 flags;
1805 	int ret = 0;
1806 
1807 	if (!inode_owner_or_capable(inode))
1808 		return -EPERM;
1809 
1810 	ret = mnt_want_write_file(file);
1811 	if (ret)
1812 		goto out;
1813 
1814 	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
1815 		ret = -EINVAL;
1816 		goto out_drop_write;
1817 	}
1818 
1819 	if (copy_from_user(&flags, arg, sizeof(flags))) {
1820 		ret = -EFAULT;
1821 		goto out_drop_write;
1822 	}
1823 
1824 	if (flags & BTRFS_SUBVOL_CREATE_ASYNC) {
1825 		ret = -EINVAL;
1826 		goto out_drop_write;
1827 	}
1828 
1829 	if (flags & ~BTRFS_SUBVOL_RDONLY) {
1830 		ret = -EOPNOTSUPP;
1831 		goto out_drop_write;
1832 	}
1833 
1834 	down_write(&root->fs_info->subvol_sem);
1835 
1836 	/* nothing to do */
1837 	if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
1838 		goto out_drop_sem;
1839 
1840 	root_flags = btrfs_root_flags(&root->root_item);
1841 	if (flags & BTRFS_SUBVOL_RDONLY) {
1842 		btrfs_set_root_flags(&root->root_item,
1843 				     root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
1844 	} else {
1845 		/*
1846 		 * Block RO -> RW transition if this subvolume is involved in
1847 		 * send
1848 		 */
1849 		spin_lock(&root->root_item_lock);
1850 		if (root->send_in_progress == 0) {
1851 			btrfs_set_root_flags(&root->root_item,
1852 				     root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
1853 			spin_unlock(&root->root_item_lock);
1854 		} else {
1855 			spin_unlock(&root->root_item_lock);
1856 			btrfs_warn(root->fs_info,
1857 			"Attempt to set subvolume %llu read-write during send",
1858 					root->root_key.objectid);
1859 			ret = -EPERM;
1860 			goto out_drop_sem;
1861 		}
1862 	}
1863 
1864 	trans = btrfs_start_transaction(root, 1);
1865 	if (IS_ERR(trans)) {
1866 		ret = PTR_ERR(trans);
1867 		goto out_reset;
1868 	}
1869 
1870 	ret = btrfs_update_root(trans, root->fs_info->tree_root,
1871 				&root->root_key, &root->root_item);
1872 
1873 	btrfs_commit_transaction(trans, root);
1874 out_reset:
1875 	if (ret)
1876 		btrfs_set_root_flags(&root->root_item, root_flags);
1877 out_drop_sem:
1878 	up_write(&root->fs_info->subvol_sem);
1879 out_drop_write:
1880 	mnt_drop_write_file(file);
1881 out:
1882 	return ret;
1883 }
1884 
1885 /*
1886  * helper to check if the subvolume references other subvolumes
1887  */
1888 static noinline int may_destroy_subvol(struct btrfs_root *root)
1889 {
1890 	struct btrfs_path *path;
1891 	struct btrfs_dir_item *di;
1892 	struct btrfs_key key;
1893 	u64 dir_id;
1894 	int ret;
1895 
1896 	path = btrfs_alloc_path();
1897 	if (!path)
1898 		return -ENOMEM;
1899 
1900 	/* Make sure this root isn't set as the default subvol */
1901 	dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
1902 	di = btrfs_lookup_dir_item(NULL, root->fs_info->tree_root, path,
1903 				   dir_id, "default", 7, 0);
1904 	if (di && !IS_ERR(di)) {
1905 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &key);
1906 		if (key.objectid == root->root_key.objectid) {
1907 			ret = -EPERM;
1908 			btrfs_err(root->fs_info, "deleting default subvolume "
1909 				  "%llu is not allowed", key.objectid);
1910 			goto out;
1911 		}
1912 		btrfs_release_path(path);
1913 	}
1914 
1915 	key.objectid = root->root_key.objectid;
1916 	key.type = BTRFS_ROOT_REF_KEY;
1917 	key.offset = (u64)-1;
1918 
1919 	ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
1920 				&key, path, 0, 0);
1921 	if (ret < 0)
1922 		goto out;
1923 	BUG_ON(ret == 0);
1924 
1925 	ret = 0;
1926 	if (path->slots[0] > 0) {
1927 		path->slots[0]--;
1928 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1929 		if (key.objectid == root->root_key.objectid &&
1930 		    key.type == BTRFS_ROOT_REF_KEY)
1931 			ret = -ENOTEMPTY;
1932 	}
1933 out:
1934 	btrfs_free_path(path);
1935 	return ret;
1936 }
1937 
1938 static noinline int key_in_sk(struct btrfs_key *key,
1939 			      struct btrfs_ioctl_search_key *sk)
1940 {
1941 	struct btrfs_key test;
1942 	int ret;
1943 
1944 	test.objectid = sk->min_objectid;
1945 	test.type = sk->min_type;
1946 	test.offset = sk->min_offset;
1947 
1948 	ret = btrfs_comp_cpu_keys(key, &test);
1949 	if (ret < 0)
1950 		return 0;
1951 
1952 	test.objectid = sk->max_objectid;
1953 	test.type = sk->max_type;
1954 	test.offset = sk->max_offset;
1955 
1956 	ret = btrfs_comp_cpu_keys(key, &test);
1957 	if (ret > 0)
1958 		return 0;
1959 	return 1;
1960 }
1961 
1962 static noinline int copy_to_sk(struct btrfs_root *root,
1963 			       struct btrfs_path *path,
1964 			       struct btrfs_key *key,
1965 			       struct btrfs_ioctl_search_key *sk,
1966 			       size_t *buf_size,
1967 			       char __user *ubuf,
1968 			       unsigned long *sk_offset,
1969 			       int *num_found)
1970 {
1971 	u64 found_transid;
1972 	struct extent_buffer *leaf;
1973 	struct btrfs_ioctl_search_header sh;
1974 	unsigned long item_off;
1975 	unsigned long item_len;
1976 	int nritems;
1977 	int i;
1978 	int slot;
1979 	int ret = 0;
1980 
1981 	leaf = path->nodes[0];
1982 	slot = path->slots[0];
1983 	nritems = btrfs_header_nritems(leaf);
1984 
1985 	if (btrfs_header_generation(leaf) > sk->max_transid) {
1986 		i = nritems;
1987 		goto advance_key;
1988 	}
1989 	found_transid = btrfs_header_generation(leaf);
1990 
1991 	for (i = slot; i < nritems; i++) {
1992 		item_off = btrfs_item_ptr_offset(leaf, i);
1993 		item_len = btrfs_item_size_nr(leaf, i);
1994 
1995 		btrfs_item_key_to_cpu(leaf, key, i);
1996 		if (!key_in_sk(key, sk))
1997 			continue;
1998 
1999 		if (sizeof(sh) + item_len > *buf_size) {
2000 			if (*num_found) {
2001 				ret = 1;
2002 				goto out;
2003 			}
2004 
2005 			/*
2006 			 * return one empty item back for v1, which does not
2007 			 * handle -EOVERFLOW
2008 			 */
2009 
2010 			*buf_size = sizeof(sh) + item_len;
2011 			item_len = 0;
2012 			ret = -EOVERFLOW;
2013 		}
2014 
2015 		if (sizeof(sh) + item_len + *sk_offset > *buf_size) {
2016 			ret = 1;
2017 			goto out;
2018 		}
2019 
2020 		sh.objectid = key->objectid;
2021 		sh.offset = key->offset;
2022 		sh.type = key->type;
2023 		sh.len = item_len;
2024 		sh.transid = found_transid;
2025 
2026 		/* copy search result header */
2027 		if (copy_to_user(ubuf + *sk_offset, &sh, sizeof(sh))) {
2028 			ret = -EFAULT;
2029 			goto out;
2030 		}
2031 
2032 		*sk_offset += sizeof(sh);
2033 
2034 		if (item_len) {
2035 			char __user *up = ubuf + *sk_offset;
2036 			/* copy the item */
2037 			if (read_extent_buffer_to_user(leaf, up,
2038 						       item_off, item_len)) {
2039 				ret = -EFAULT;
2040 				goto out;
2041 			}
2042 
2043 			*sk_offset += item_len;
2044 		}
2045 		(*num_found)++;
2046 
2047 		if (ret) /* -EOVERFLOW from above */
2048 			goto out;
2049 
2050 		if (*num_found >= sk->nr_items) {
2051 			ret = 1;
2052 			goto out;
2053 		}
2054 	}
2055 advance_key:
2056 	ret = 0;
2057 	if (key->offset < (u64)-1 && key->offset < sk->max_offset)
2058 		key->offset++;
2059 	else if (key->type < (u8)-1 && key->type < sk->max_type) {
2060 		key->offset = 0;
2061 		key->type++;
2062 	} else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) {
2063 		key->offset = 0;
2064 		key->type = 0;
2065 		key->objectid++;
2066 	} else
2067 		ret = 1;
2068 out:
2069 	/*
2070 	 *  0: all items from this leaf copied, continue with next
2071 	 *  1: * more items can be copied, but unused buffer is too small
2072 	 *     * all items were found
2073 	 *     Either way, it will stops the loop which iterates to the next
2074 	 *     leaf
2075 	 *  -EOVERFLOW: item was to large for buffer
2076 	 *  -EFAULT: could not copy extent buffer back to userspace
2077 	 */
2078 	return ret;
2079 }
2080 
2081 static noinline int search_ioctl(struct inode *inode,
2082 				 struct btrfs_ioctl_search_key *sk,
2083 				 size_t *buf_size,
2084 				 char __user *ubuf)
2085 {
2086 	struct btrfs_root *root;
2087 	struct btrfs_key key;
2088 	struct btrfs_path *path;
2089 	struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info;
2090 	int ret;
2091 	int num_found = 0;
2092 	unsigned long sk_offset = 0;
2093 
2094 	if (*buf_size < sizeof(struct btrfs_ioctl_search_header)) {
2095 		*buf_size = sizeof(struct btrfs_ioctl_search_header);
2096 		return -EOVERFLOW;
2097 	}
2098 
2099 	path = btrfs_alloc_path();
2100 	if (!path)
2101 		return -ENOMEM;
2102 
2103 	if (sk->tree_id == 0) {
2104 		/* search the root of the inode that was passed */
2105 		root = BTRFS_I(inode)->root;
2106 	} else {
2107 		key.objectid = sk->tree_id;
2108 		key.type = BTRFS_ROOT_ITEM_KEY;
2109 		key.offset = (u64)-1;
2110 		root = btrfs_read_fs_root_no_name(info, &key);
2111 		if (IS_ERR(root)) {
2112 			printk(KERN_ERR "BTRFS: could not find root %llu\n",
2113 			       sk->tree_id);
2114 			btrfs_free_path(path);
2115 			return -ENOENT;
2116 		}
2117 	}
2118 
2119 	key.objectid = sk->min_objectid;
2120 	key.type = sk->min_type;
2121 	key.offset = sk->min_offset;
2122 
2123 	while (1) {
2124 		ret = btrfs_search_forward(root, &key, path, sk->min_transid);
2125 		if (ret != 0) {
2126 			if (ret > 0)
2127 				ret = 0;
2128 			goto err;
2129 		}
2130 		ret = copy_to_sk(root, path, &key, sk, buf_size, ubuf,
2131 				 &sk_offset, &num_found);
2132 		btrfs_release_path(path);
2133 		if (ret)
2134 			break;
2135 
2136 	}
2137 	if (ret > 0)
2138 		ret = 0;
2139 err:
2140 	sk->nr_items = num_found;
2141 	btrfs_free_path(path);
2142 	return ret;
2143 }
2144 
2145 static noinline int btrfs_ioctl_tree_search(struct file *file,
2146 					   void __user *argp)
2147 {
2148 	struct btrfs_ioctl_search_args __user *uargs;
2149 	struct btrfs_ioctl_search_key sk;
2150 	struct inode *inode;
2151 	int ret;
2152 	size_t buf_size;
2153 
2154 	if (!capable(CAP_SYS_ADMIN))
2155 		return -EPERM;
2156 
2157 	uargs = (struct btrfs_ioctl_search_args __user *)argp;
2158 
2159 	if (copy_from_user(&sk, &uargs->key, sizeof(sk)))
2160 		return -EFAULT;
2161 
2162 	buf_size = sizeof(uargs->buf);
2163 
2164 	inode = file_inode(file);
2165 	ret = search_ioctl(inode, &sk, &buf_size, uargs->buf);
2166 
2167 	/*
2168 	 * In the origin implementation an overflow is handled by returning a
2169 	 * search header with a len of zero, so reset ret.
2170 	 */
2171 	if (ret == -EOVERFLOW)
2172 		ret = 0;
2173 
2174 	if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk)))
2175 		ret = -EFAULT;
2176 	return ret;
2177 }
2178 
2179 static noinline int btrfs_ioctl_tree_search_v2(struct file *file,
2180 					       void __user *argp)
2181 {
2182 	struct btrfs_ioctl_search_args_v2 __user *uarg;
2183 	struct btrfs_ioctl_search_args_v2 args;
2184 	struct inode *inode;
2185 	int ret;
2186 	size_t buf_size;
2187 	const size_t buf_limit = 16 * 1024 * 1024;
2188 
2189 	if (!capable(CAP_SYS_ADMIN))
2190 		return -EPERM;
2191 
2192 	/* copy search header and buffer size */
2193 	uarg = (struct btrfs_ioctl_search_args_v2 __user *)argp;
2194 	if (copy_from_user(&args, uarg, sizeof(args)))
2195 		return -EFAULT;
2196 
2197 	buf_size = args.buf_size;
2198 
2199 	if (buf_size < sizeof(struct btrfs_ioctl_search_header))
2200 		return -EOVERFLOW;
2201 
2202 	/* limit result size to 16MB */
2203 	if (buf_size > buf_limit)
2204 		buf_size = buf_limit;
2205 
2206 	inode = file_inode(file);
2207 	ret = search_ioctl(inode, &args.key, &buf_size,
2208 			   (char *)(&uarg->buf[0]));
2209 	if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key)))
2210 		ret = -EFAULT;
2211 	else if (ret == -EOVERFLOW &&
2212 		copy_to_user(&uarg->buf_size, &buf_size, sizeof(buf_size)))
2213 		ret = -EFAULT;
2214 
2215 	return ret;
2216 }
2217 
2218 /*
2219  * Search INODE_REFs to identify path name of 'dirid' directory
2220  * in a 'tree_id' tree. and sets path name to 'name'.
2221  */
2222 static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
2223 				u64 tree_id, u64 dirid, char *name)
2224 {
2225 	struct btrfs_root *root;
2226 	struct btrfs_key key;
2227 	char *ptr;
2228 	int ret = -1;
2229 	int slot;
2230 	int len;
2231 	int total_len = 0;
2232 	struct btrfs_inode_ref *iref;
2233 	struct extent_buffer *l;
2234 	struct btrfs_path *path;
2235 
2236 	if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
2237 		name[0]='\0';
2238 		return 0;
2239 	}
2240 
2241 	path = btrfs_alloc_path();
2242 	if (!path)
2243 		return -ENOMEM;
2244 
2245 	ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX];
2246 
2247 	key.objectid = tree_id;
2248 	key.type = BTRFS_ROOT_ITEM_KEY;
2249 	key.offset = (u64)-1;
2250 	root = btrfs_read_fs_root_no_name(info, &key);
2251 	if (IS_ERR(root)) {
2252 		printk(KERN_ERR "BTRFS: could not find root %llu\n", tree_id);
2253 		ret = -ENOENT;
2254 		goto out;
2255 	}
2256 
2257 	key.objectid = dirid;
2258 	key.type = BTRFS_INODE_REF_KEY;
2259 	key.offset = (u64)-1;
2260 
2261 	while (1) {
2262 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2263 		if (ret < 0)
2264 			goto out;
2265 		else if (ret > 0) {
2266 			ret = btrfs_previous_item(root, path, dirid,
2267 						  BTRFS_INODE_REF_KEY);
2268 			if (ret < 0)
2269 				goto out;
2270 			else if (ret > 0) {
2271 				ret = -ENOENT;
2272 				goto out;
2273 			}
2274 		}
2275 
2276 		l = path->nodes[0];
2277 		slot = path->slots[0];
2278 		btrfs_item_key_to_cpu(l, &key, slot);
2279 
2280 		iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
2281 		len = btrfs_inode_ref_name_len(l, iref);
2282 		ptr -= len + 1;
2283 		total_len += len + 1;
2284 		if (ptr < name) {
2285 			ret = -ENAMETOOLONG;
2286 			goto out;
2287 		}
2288 
2289 		*(ptr + len) = '/';
2290 		read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len);
2291 
2292 		if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
2293 			break;
2294 
2295 		btrfs_release_path(path);
2296 		key.objectid = key.offset;
2297 		key.offset = (u64)-1;
2298 		dirid = key.objectid;
2299 	}
2300 	memmove(name, ptr, total_len);
2301 	name[total_len] = '\0';
2302 	ret = 0;
2303 out:
2304 	btrfs_free_path(path);
2305 	return ret;
2306 }
2307 
2308 static noinline int btrfs_ioctl_ino_lookup(struct file *file,
2309 					   void __user *argp)
2310 {
2311 	 struct btrfs_ioctl_ino_lookup_args *args;
2312 	 struct inode *inode;
2313 	 int ret;
2314 
2315 	if (!capable(CAP_SYS_ADMIN))
2316 		return -EPERM;
2317 
2318 	args = memdup_user(argp, sizeof(*args));
2319 	if (IS_ERR(args))
2320 		return PTR_ERR(args);
2321 
2322 	inode = file_inode(file);
2323 
2324 	if (args->treeid == 0)
2325 		args->treeid = BTRFS_I(inode)->root->root_key.objectid;
2326 
2327 	ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
2328 					args->treeid, args->objectid,
2329 					args->name);
2330 
2331 	if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2332 		ret = -EFAULT;
2333 
2334 	kfree(args);
2335 	return ret;
2336 }
2337 
2338 static noinline int btrfs_ioctl_snap_destroy(struct file *file,
2339 					     void __user *arg)
2340 {
2341 	struct dentry *parent = file->f_path.dentry;
2342 	struct dentry *dentry;
2343 	struct inode *dir = parent->d_inode;
2344 	struct inode *inode;
2345 	struct btrfs_root *root = BTRFS_I(dir)->root;
2346 	struct btrfs_root *dest = NULL;
2347 	struct btrfs_ioctl_vol_args *vol_args;
2348 	struct btrfs_trans_handle *trans;
2349 	struct btrfs_block_rsv block_rsv;
2350 	u64 root_flags;
2351 	u64 qgroup_reserved;
2352 	int namelen;
2353 	int ret;
2354 	int err = 0;
2355 
2356 	vol_args = memdup_user(arg, sizeof(*vol_args));
2357 	if (IS_ERR(vol_args))
2358 		return PTR_ERR(vol_args);
2359 
2360 	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2361 	namelen = strlen(vol_args->name);
2362 	if (strchr(vol_args->name, '/') ||
2363 	    strncmp(vol_args->name, "..", namelen) == 0) {
2364 		err = -EINVAL;
2365 		goto out;
2366 	}
2367 
2368 	err = mnt_want_write_file(file);
2369 	if (err)
2370 		goto out;
2371 
2372 
2373 	err = mutex_lock_killable_nested(&dir->i_mutex, I_MUTEX_PARENT);
2374 	if (err == -EINTR)
2375 		goto out_drop_write;
2376 	dentry = lookup_one_len(vol_args->name, parent, namelen);
2377 	if (IS_ERR(dentry)) {
2378 		err = PTR_ERR(dentry);
2379 		goto out_unlock_dir;
2380 	}
2381 
2382 	if (!dentry->d_inode) {
2383 		err = -ENOENT;
2384 		goto out_dput;
2385 	}
2386 
2387 	inode = dentry->d_inode;
2388 	dest = BTRFS_I(inode)->root;
2389 	if (!capable(CAP_SYS_ADMIN)) {
2390 		/*
2391 		 * Regular user.  Only allow this with a special mount
2392 		 * option, when the user has write+exec access to the
2393 		 * subvol root, and when rmdir(2) would have been
2394 		 * allowed.
2395 		 *
2396 		 * Note that this is _not_ check that the subvol is
2397 		 * empty or doesn't contain data that we wouldn't
2398 		 * otherwise be able to delete.
2399 		 *
2400 		 * Users who want to delete empty subvols should try
2401 		 * rmdir(2).
2402 		 */
2403 		err = -EPERM;
2404 		if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
2405 			goto out_dput;
2406 
2407 		/*
2408 		 * Do not allow deletion if the parent dir is the same
2409 		 * as the dir to be deleted.  That means the ioctl
2410 		 * must be called on the dentry referencing the root
2411 		 * of the subvol, not a random directory contained
2412 		 * within it.
2413 		 */
2414 		err = -EINVAL;
2415 		if (root == dest)
2416 			goto out_dput;
2417 
2418 		err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
2419 		if (err)
2420 			goto out_dput;
2421 	}
2422 
2423 	/* check if subvolume may be deleted by a user */
2424 	err = btrfs_may_delete(dir, dentry, 1);
2425 	if (err)
2426 		goto out_dput;
2427 
2428 	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
2429 		err = -EINVAL;
2430 		goto out_dput;
2431 	}
2432 
2433 	mutex_lock(&inode->i_mutex);
2434 
2435 	/*
2436 	 * Don't allow to delete a subvolume with send in progress. This is
2437 	 * inside the i_mutex so the error handling that has to drop the bit
2438 	 * again is not run concurrently.
2439 	 */
2440 	spin_lock(&dest->root_item_lock);
2441 	root_flags = btrfs_root_flags(&dest->root_item);
2442 	if (dest->send_in_progress == 0) {
2443 		btrfs_set_root_flags(&dest->root_item,
2444 				root_flags | BTRFS_ROOT_SUBVOL_DEAD);
2445 		spin_unlock(&dest->root_item_lock);
2446 	} else {
2447 		spin_unlock(&dest->root_item_lock);
2448 		btrfs_warn(root->fs_info,
2449 			"Attempt to delete subvolume %llu during send",
2450 			dest->root_key.objectid);
2451 		err = -EPERM;
2452 		goto out_dput;
2453 	}
2454 
2455 	d_invalidate(dentry);
2456 
2457 	down_write(&root->fs_info->subvol_sem);
2458 
2459 	err = may_destroy_subvol(dest);
2460 	if (err)
2461 		goto out_up_write;
2462 
2463 	btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
2464 	/*
2465 	 * One for dir inode, two for dir entries, two for root
2466 	 * ref/backref.
2467 	 */
2468 	err = btrfs_subvolume_reserve_metadata(root, &block_rsv,
2469 					       5, &qgroup_reserved, true);
2470 	if (err)
2471 		goto out_up_write;
2472 
2473 	trans = btrfs_start_transaction(root, 0);
2474 	if (IS_ERR(trans)) {
2475 		err = PTR_ERR(trans);
2476 		goto out_release;
2477 	}
2478 	trans->block_rsv = &block_rsv;
2479 	trans->bytes_reserved = block_rsv.size;
2480 
2481 	ret = btrfs_unlink_subvol(trans, root, dir,
2482 				dest->root_key.objectid,
2483 				dentry->d_name.name,
2484 				dentry->d_name.len);
2485 	if (ret) {
2486 		err = ret;
2487 		btrfs_abort_transaction(trans, root, ret);
2488 		goto out_end_trans;
2489 	}
2490 
2491 	btrfs_record_root_in_trans(trans, dest);
2492 
2493 	memset(&dest->root_item.drop_progress, 0,
2494 		sizeof(dest->root_item.drop_progress));
2495 	dest->root_item.drop_level = 0;
2496 	btrfs_set_root_refs(&dest->root_item, 0);
2497 
2498 	if (!test_and_set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &dest->state)) {
2499 		ret = btrfs_insert_orphan_item(trans,
2500 					root->fs_info->tree_root,
2501 					dest->root_key.objectid);
2502 		if (ret) {
2503 			btrfs_abort_transaction(trans, root, ret);
2504 			err = ret;
2505 			goto out_end_trans;
2506 		}
2507 	}
2508 
2509 	ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
2510 				  dest->root_item.uuid, BTRFS_UUID_KEY_SUBVOL,
2511 				  dest->root_key.objectid);
2512 	if (ret && ret != -ENOENT) {
2513 		btrfs_abort_transaction(trans, root, ret);
2514 		err = ret;
2515 		goto out_end_trans;
2516 	}
2517 	if (!btrfs_is_empty_uuid(dest->root_item.received_uuid)) {
2518 		ret = btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
2519 					  dest->root_item.received_uuid,
2520 					  BTRFS_UUID_KEY_RECEIVED_SUBVOL,
2521 					  dest->root_key.objectid);
2522 		if (ret && ret != -ENOENT) {
2523 			btrfs_abort_transaction(trans, root, ret);
2524 			err = ret;
2525 			goto out_end_trans;
2526 		}
2527 	}
2528 
2529 out_end_trans:
2530 	trans->block_rsv = NULL;
2531 	trans->bytes_reserved = 0;
2532 	ret = btrfs_end_transaction(trans, root);
2533 	if (ret && !err)
2534 		err = ret;
2535 	inode->i_flags |= S_DEAD;
2536 out_release:
2537 	btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
2538 out_up_write:
2539 	up_write(&root->fs_info->subvol_sem);
2540 	if (err) {
2541 		spin_lock(&dest->root_item_lock);
2542 		root_flags = btrfs_root_flags(&dest->root_item);
2543 		btrfs_set_root_flags(&dest->root_item,
2544 				root_flags & ~BTRFS_ROOT_SUBVOL_DEAD);
2545 		spin_unlock(&dest->root_item_lock);
2546 	}
2547 	mutex_unlock(&inode->i_mutex);
2548 	if (!err) {
2549 		shrink_dcache_sb(root->fs_info->sb);
2550 		btrfs_invalidate_inodes(dest);
2551 		d_delete(dentry);
2552 		ASSERT(dest->send_in_progress == 0);
2553 
2554 		/* the last ref */
2555 		if (dest->ino_cache_inode) {
2556 			iput(dest->ino_cache_inode);
2557 			dest->ino_cache_inode = NULL;
2558 		}
2559 	}
2560 out_dput:
2561 	dput(dentry);
2562 out_unlock_dir:
2563 	mutex_unlock(&dir->i_mutex);
2564 out_drop_write:
2565 	mnt_drop_write_file(file);
2566 out:
2567 	kfree(vol_args);
2568 	return err;
2569 }
2570 
2571 static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
2572 {
2573 	struct inode *inode = file_inode(file);
2574 	struct btrfs_root *root = BTRFS_I(inode)->root;
2575 	struct btrfs_ioctl_defrag_range_args *range;
2576 	int ret;
2577 
2578 	ret = mnt_want_write_file(file);
2579 	if (ret)
2580 		return ret;
2581 
2582 	if (btrfs_root_readonly(root)) {
2583 		ret = -EROFS;
2584 		goto out;
2585 	}
2586 
2587 	switch (inode->i_mode & S_IFMT) {
2588 	case S_IFDIR:
2589 		if (!capable(CAP_SYS_ADMIN)) {
2590 			ret = -EPERM;
2591 			goto out;
2592 		}
2593 		ret = btrfs_defrag_root(root);
2594 		if (ret)
2595 			goto out;
2596 		ret = btrfs_defrag_root(root->fs_info->extent_root);
2597 		break;
2598 	case S_IFREG:
2599 		if (!(file->f_mode & FMODE_WRITE)) {
2600 			ret = -EINVAL;
2601 			goto out;
2602 		}
2603 
2604 		range = kzalloc(sizeof(*range), GFP_KERNEL);
2605 		if (!range) {
2606 			ret = -ENOMEM;
2607 			goto out;
2608 		}
2609 
2610 		if (argp) {
2611 			if (copy_from_user(range, argp,
2612 					   sizeof(*range))) {
2613 				ret = -EFAULT;
2614 				kfree(range);
2615 				goto out;
2616 			}
2617 			/* compression requires us to start the IO */
2618 			if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
2619 				range->flags |= BTRFS_DEFRAG_RANGE_START_IO;
2620 				range->extent_thresh = (u32)-1;
2621 			}
2622 		} else {
2623 			/* the rest are all set to zero by kzalloc */
2624 			range->len = (u64)-1;
2625 		}
2626 		ret = btrfs_defrag_file(file_inode(file), file,
2627 					range, 0, 0);
2628 		if (ret > 0)
2629 			ret = 0;
2630 		kfree(range);
2631 		break;
2632 	default:
2633 		ret = -EINVAL;
2634 	}
2635 out:
2636 	mnt_drop_write_file(file);
2637 	return ret;
2638 }
2639 
2640 static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
2641 {
2642 	struct btrfs_ioctl_vol_args *vol_args;
2643 	int ret;
2644 
2645 	if (!capable(CAP_SYS_ADMIN))
2646 		return -EPERM;
2647 
2648 	if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
2649 			1)) {
2650 		return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
2651 	}
2652 
2653 	mutex_lock(&root->fs_info->volume_mutex);
2654 	vol_args = memdup_user(arg, sizeof(*vol_args));
2655 	if (IS_ERR(vol_args)) {
2656 		ret = PTR_ERR(vol_args);
2657 		goto out;
2658 	}
2659 
2660 	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2661 	ret = btrfs_init_new_device(root, vol_args->name);
2662 
2663 	if (!ret)
2664 		btrfs_info(root->fs_info, "disk added %s",vol_args->name);
2665 
2666 	kfree(vol_args);
2667 out:
2668 	mutex_unlock(&root->fs_info->volume_mutex);
2669 	atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
2670 	return ret;
2671 }
2672 
2673 static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
2674 {
2675 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
2676 	struct btrfs_ioctl_vol_args *vol_args;
2677 	int ret;
2678 
2679 	if (!capable(CAP_SYS_ADMIN))
2680 		return -EPERM;
2681 
2682 	ret = mnt_want_write_file(file);
2683 	if (ret)
2684 		return ret;
2685 
2686 	vol_args = memdup_user(arg, sizeof(*vol_args));
2687 	if (IS_ERR(vol_args)) {
2688 		ret = PTR_ERR(vol_args);
2689 		goto err_drop;
2690 	}
2691 
2692 	vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2693 
2694 	if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
2695 			1)) {
2696 		ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
2697 		goto out;
2698 	}
2699 
2700 	mutex_lock(&root->fs_info->volume_mutex);
2701 	ret = btrfs_rm_device(root, vol_args->name);
2702 	mutex_unlock(&root->fs_info->volume_mutex);
2703 	atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
2704 
2705 	if (!ret)
2706 		btrfs_info(root->fs_info, "disk deleted %s",vol_args->name);
2707 
2708 out:
2709 	kfree(vol_args);
2710 err_drop:
2711 	mnt_drop_write_file(file);
2712 	return ret;
2713 }
2714 
2715 static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
2716 {
2717 	struct btrfs_ioctl_fs_info_args *fi_args;
2718 	struct btrfs_device *device;
2719 	struct btrfs_device *next;
2720 	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
2721 	int ret = 0;
2722 
2723 	fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
2724 	if (!fi_args)
2725 		return -ENOMEM;
2726 
2727 	mutex_lock(&fs_devices->device_list_mutex);
2728 	fi_args->num_devices = fs_devices->num_devices;
2729 	memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
2730 
2731 	list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
2732 		if (device->devid > fi_args->max_id)
2733 			fi_args->max_id = device->devid;
2734 	}
2735 	mutex_unlock(&fs_devices->device_list_mutex);
2736 
2737 	fi_args->nodesize = root->fs_info->super_copy->nodesize;
2738 	fi_args->sectorsize = root->fs_info->super_copy->sectorsize;
2739 	fi_args->clone_alignment = root->fs_info->super_copy->sectorsize;
2740 
2741 	if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
2742 		ret = -EFAULT;
2743 
2744 	kfree(fi_args);
2745 	return ret;
2746 }
2747 
2748 static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
2749 {
2750 	struct btrfs_ioctl_dev_info_args *di_args;
2751 	struct btrfs_device *dev;
2752 	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
2753 	int ret = 0;
2754 	char *s_uuid = NULL;
2755 
2756 	di_args = memdup_user(arg, sizeof(*di_args));
2757 	if (IS_ERR(di_args))
2758 		return PTR_ERR(di_args);
2759 
2760 	if (!btrfs_is_empty_uuid(di_args->uuid))
2761 		s_uuid = di_args->uuid;
2762 
2763 	mutex_lock(&fs_devices->device_list_mutex);
2764 	dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL);
2765 
2766 	if (!dev) {
2767 		ret = -ENODEV;
2768 		goto out;
2769 	}
2770 
2771 	di_args->devid = dev->devid;
2772 	di_args->bytes_used = btrfs_device_get_bytes_used(dev);
2773 	di_args->total_bytes = btrfs_device_get_total_bytes(dev);
2774 	memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
2775 	if (dev->name) {
2776 		struct rcu_string *name;
2777 
2778 		rcu_read_lock();
2779 		name = rcu_dereference(dev->name);
2780 		strncpy(di_args->path, name->str, sizeof(di_args->path));
2781 		rcu_read_unlock();
2782 		di_args->path[sizeof(di_args->path) - 1] = 0;
2783 	} else {
2784 		di_args->path[0] = '\0';
2785 	}
2786 
2787 out:
2788 	mutex_unlock(&fs_devices->device_list_mutex);
2789 	if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
2790 		ret = -EFAULT;
2791 
2792 	kfree(di_args);
2793 	return ret;
2794 }
2795 
2796 static struct page *extent_same_get_page(struct inode *inode, u64 off)
2797 {
2798 	struct page *page;
2799 	pgoff_t index;
2800 	struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
2801 
2802 	index = off >> PAGE_CACHE_SHIFT;
2803 
2804 	page = grab_cache_page(inode->i_mapping, index);
2805 	if (!page)
2806 		return NULL;
2807 
2808 	if (!PageUptodate(page)) {
2809 		if (extent_read_full_page_nolock(tree, page, btrfs_get_extent,
2810 						 0))
2811 			return NULL;
2812 		lock_page(page);
2813 		if (!PageUptodate(page)) {
2814 			unlock_page(page);
2815 			page_cache_release(page);
2816 			return NULL;
2817 		}
2818 	}
2819 	unlock_page(page);
2820 
2821 	return page;
2822 }
2823 
2824 static inline void lock_extent_range(struct inode *inode, u64 off, u64 len)
2825 {
2826 	/* do any pending delalloc/csum calc on src, one way or
2827 	   another, and lock file content */
2828 	while (1) {
2829 		struct btrfs_ordered_extent *ordered;
2830 		lock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1);
2831 		ordered = btrfs_lookup_first_ordered_extent(inode,
2832 							    off + len - 1);
2833 		if ((!ordered ||
2834 		     ordered->file_offset + ordered->len <= off ||
2835 		     ordered->file_offset >= off + len) &&
2836 		    !test_range_bit(&BTRFS_I(inode)->io_tree, off,
2837 				    off + len - 1, EXTENT_DELALLOC, 0, NULL)) {
2838 			if (ordered)
2839 				btrfs_put_ordered_extent(ordered);
2840 			break;
2841 		}
2842 		unlock_extent(&BTRFS_I(inode)->io_tree, off, off + len - 1);
2843 		if (ordered)
2844 			btrfs_put_ordered_extent(ordered);
2845 		btrfs_wait_ordered_range(inode, off, len);
2846 	}
2847 }
2848 
2849 static void btrfs_double_unlock(struct inode *inode1, u64 loff1,
2850 				struct inode *inode2, u64 loff2, u64 len)
2851 {
2852 	unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1);
2853 	unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1);
2854 
2855 	mutex_unlock(&inode1->i_mutex);
2856 	mutex_unlock(&inode2->i_mutex);
2857 }
2858 
2859 static void btrfs_double_lock(struct inode *inode1, u64 loff1,
2860 			      struct inode *inode2, u64 loff2, u64 len)
2861 {
2862 	if (inode1 < inode2) {
2863 		swap(inode1, inode2);
2864 		swap(loff1, loff2);
2865 	}
2866 
2867 	mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT);
2868 	lock_extent_range(inode1, loff1, len);
2869 	if (inode1 != inode2) {
2870 		mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD);
2871 		lock_extent_range(inode2, loff2, len);
2872 	}
2873 }
2874 
2875 static int btrfs_cmp_data(struct inode *src, u64 loff, struct inode *dst,
2876 			  u64 dst_loff, u64 len)
2877 {
2878 	int ret = 0;
2879 	struct page *src_page, *dst_page;
2880 	unsigned int cmp_len = PAGE_CACHE_SIZE;
2881 	void *addr, *dst_addr;
2882 
2883 	while (len) {
2884 		if (len < PAGE_CACHE_SIZE)
2885 			cmp_len = len;
2886 
2887 		src_page = extent_same_get_page(src, loff);
2888 		if (!src_page)
2889 			return -EINVAL;
2890 		dst_page = extent_same_get_page(dst, dst_loff);
2891 		if (!dst_page) {
2892 			page_cache_release(src_page);
2893 			return -EINVAL;
2894 		}
2895 		addr = kmap_atomic(src_page);
2896 		dst_addr = kmap_atomic(dst_page);
2897 
2898 		flush_dcache_page(src_page);
2899 		flush_dcache_page(dst_page);
2900 
2901 		if (memcmp(addr, dst_addr, cmp_len))
2902 			ret = BTRFS_SAME_DATA_DIFFERS;
2903 
2904 		kunmap_atomic(addr);
2905 		kunmap_atomic(dst_addr);
2906 		page_cache_release(src_page);
2907 		page_cache_release(dst_page);
2908 
2909 		if (ret)
2910 			break;
2911 
2912 		loff += cmp_len;
2913 		dst_loff += cmp_len;
2914 		len -= cmp_len;
2915 	}
2916 
2917 	return ret;
2918 }
2919 
2920 static int extent_same_check_offsets(struct inode *inode, u64 off, u64 len)
2921 {
2922 	u64 bs = BTRFS_I(inode)->root->fs_info->sb->s_blocksize;
2923 
2924 	if (off + len > inode->i_size || off + len < off)
2925 		return -EINVAL;
2926 	/* Check that we are block aligned - btrfs_clone() requires this */
2927 	if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs))
2928 		return -EINVAL;
2929 
2930 	return 0;
2931 }
2932 
2933 static int btrfs_extent_same(struct inode *src, u64 loff, u64 len,
2934 			     struct inode *dst, u64 dst_loff)
2935 {
2936 	int ret;
2937 
2938 	/*
2939 	 * btrfs_clone() can't handle extents in the same file
2940 	 * yet. Once that works, we can drop this check and replace it
2941 	 * with a check for the same inode, but overlapping extents.
2942 	 */
2943 	if (src == dst)
2944 		return -EINVAL;
2945 
2946 	btrfs_double_lock(src, loff, dst, dst_loff, len);
2947 
2948 	ret = extent_same_check_offsets(src, loff, len);
2949 	if (ret)
2950 		goto out_unlock;
2951 
2952 	ret = extent_same_check_offsets(dst, dst_loff, len);
2953 	if (ret)
2954 		goto out_unlock;
2955 
2956 	/* don't make the dst file partly checksummed */
2957 	if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
2958 	    (BTRFS_I(dst)->flags & BTRFS_INODE_NODATASUM)) {
2959 		ret = -EINVAL;
2960 		goto out_unlock;
2961 	}
2962 
2963 	ret = btrfs_cmp_data(src, loff, dst, dst_loff, len);
2964 	if (ret == 0)
2965 		ret = btrfs_clone(src, dst, loff, len, len, dst_loff);
2966 
2967 out_unlock:
2968 	btrfs_double_unlock(src, loff, dst, dst_loff, len);
2969 
2970 	return ret;
2971 }
2972 
2973 #define BTRFS_MAX_DEDUPE_LEN	(16 * 1024 * 1024)
2974 
2975 static long btrfs_ioctl_file_extent_same(struct file *file,
2976 			struct btrfs_ioctl_same_args __user *argp)
2977 {
2978 	struct btrfs_ioctl_same_args *same;
2979 	struct btrfs_ioctl_same_extent_info *info;
2980 	struct inode *src = file_inode(file);
2981 	u64 off;
2982 	u64 len;
2983 	int i;
2984 	int ret;
2985 	unsigned long size;
2986 	u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize;
2987 	bool is_admin = capable(CAP_SYS_ADMIN);
2988 	u16 count;
2989 
2990 	if (!(file->f_mode & FMODE_READ))
2991 		return -EINVAL;
2992 
2993 	ret = mnt_want_write_file(file);
2994 	if (ret)
2995 		return ret;
2996 
2997 	if (get_user(count, &argp->dest_count)) {
2998 		ret = -EFAULT;
2999 		goto out;
3000 	}
3001 
3002 	size = offsetof(struct btrfs_ioctl_same_args __user, info[count]);
3003 
3004 	same = memdup_user(argp, size);
3005 
3006 	if (IS_ERR(same)) {
3007 		ret = PTR_ERR(same);
3008 		goto out;
3009 	}
3010 
3011 	off = same->logical_offset;
3012 	len = same->length;
3013 
3014 	/*
3015 	 * Limit the total length we will dedupe for each operation.
3016 	 * This is intended to bound the total time spent in this
3017 	 * ioctl to something sane.
3018 	 */
3019 	if (len > BTRFS_MAX_DEDUPE_LEN)
3020 		len = BTRFS_MAX_DEDUPE_LEN;
3021 
3022 	if (WARN_ON_ONCE(bs < PAGE_CACHE_SIZE)) {
3023 		/*
3024 		 * Btrfs does not support blocksize < page_size. As a
3025 		 * result, btrfs_cmp_data() won't correctly handle
3026 		 * this situation without an update.
3027 		 */
3028 		ret = -EINVAL;
3029 		goto out;
3030 	}
3031 
3032 	ret = -EISDIR;
3033 	if (S_ISDIR(src->i_mode))
3034 		goto out;
3035 
3036 	ret = -EACCES;
3037 	if (!S_ISREG(src->i_mode))
3038 		goto out;
3039 
3040 	/* pre-format output fields to sane values */
3041 	for (i = 0; i < count; i++) {
3042 		same->info[i].bytes_deduped = 0ULL;
3043 		same->info[i].status = 0;
3044 	}
3045 
3046 	for (i = 0, info = same->info; i < count; i++, info++) {
3047 		struct inode *dst;
3048 		struct fd dst_file = fdget(info->fd);
3049 		if (!dst_file.file) {
3050 			info->status = -EBADF;
3051 			continue;
3052 		}
3053 		dst = file_inode(dst_file.file);
3054 
3055 		if (!(is_admin || (dst_file.file->f_mode & FMODE_WRITE))) {
3056 			info->status = -EINVAL;
3057 		} else if (file->f_path.mnt != dst_file.file->f_path.mnt) {
3058 			info->status = -EXDEV;
3059 		} else if (S_ISDIR(dst->i_mode)) {
3060 			info->status = -EISDIR;
3061 		} else if (!S_ISREG(dst->i_mode)) {
3062 			info->status = -EACCES;
3063 		} else {
3064 			info->status = btrfs_extent_same(src, off, len, dst,
3065 							info->logical_offset);
3066 			if (info->status == 0)
3067 				info->bytes_deduped += len;
3068 		}
3069 		fdput(dst_file);
3070 	}
3071 
3072 	ret = copy_to_user(argp, same, size);
3073 	if (ret)
3074 		ret = -EFAULT;
3075 
3076 out:
3077 	mnt_drop_write_file(file);
3078 	return ret;
3079 }
3080 
3081 /* Helper to check and see if this root currently has a ref on the given disk
3082  * bytenr.  If it does then we need to update the quota for this root.  This
3083  * doesn't do anything if quotas aren't enabled.
3084  */
3085 static int check_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3086 		     u64 disko)
3087 {
3088 	struct seq_list tree_mod_seq_elem = {};
3089 	struct ulist *roots;
3090 	struct ulist_iterator uiter;
3091 	struct ulist_node *root_node = NULL;
3092 	int ret;
3093 
3094 	if (!root->fs_info->quota_enabled)
3095 		return 1;
3096 
3097 	btrfs_get_tree_mod_seq(root->fs_info, &tree_mod_seq_elem);
3098 	ret = btrfs_find_all_roots(trans, root->fs_info, disko,
3099 				   tree_mod_seq_elem.seq, &roots);
3100 	if (ret < 0)
3101 		goto out;
3102 	ret = 0;
3103 	ULIST_ITER_INIT(&uiter);
3104 	while ((root_node = ulist_next(roots, &uiter))) {
3105 		if (root_node->val == root->objectid) {
3106 			ret = 1;
3107 			break;
3108 		}
3109 	}
3110 	ulist_free(roots);
3111 out:
3112 	btrfs_put_tree_mod_seq(root->fs_info, &tree_mod_seq_elem);
3113 	return ret;
3114 }
3115 
3116 static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
3117 				     struct inode *inode,
3118 				     u64 endoff,
3119 				     const u64 destoff,
3120 				     const u64 olen)
3121 {
3122 	struct btrfs_root *root = BTRFS_I(inode)->root;
3123 	int ret;
3124 
3125 	inode_inc_iversion(inode);
3126 	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
3127 	/*
3128 	 * We round up to the block size at eof when determining which
3129 	 * extents to clone above, but shouldn't round up the file size.
3130 	 */
3131 	if (endoff > destoff + olen)
3132 		endoff = destoff + olen;
3133 	if (endoff > inode->i_size)
3134 		btrfs_i_size_write(inode, endoff);
3135 
3136 	ret = btrfs_update_inode(trans, root, inode);
3137 	if (ret) {
3138 		btrfs_abort_transaction(trans, root, ret);
3139 		btrfs_end_transaction(trans, root);
3140 		goto out;
3141 	}
3142 	ret = btrfs_end_transaction(trans, root);
3143 out:
3144 	return ret;
3145 }
3146 
3147 static void clone_update_extent_map(struct inode *inode,
3148 				    const struct btrfs_trans_handle *trans,
3149 				    const struct btrfs_path *path,
3150 				    const u64 hole_offset,
3151 				    const u64 hole_len)
3152 {
3153 	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
3154 	struct extent_map *em;
3155 	int ret;
3156 
3157 	em = alloc_extent_map();
3158 	if (!em) {
3159 		set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3160 			&BTRFS_I(inode)->runtime_flags);
3161 		return;
3162 	}
3163 
3164 	if (path) {
3165 		struct btrfs_file_extent_item *fi;
3166 
3167 		fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
3168 				    struct btrfs_file_extent_item);
3169 		btrfs_extent_item_to_extent_map(inode, path, fi, false, em);
3170 		em->generation = -1;
3171 		if (btrfs_file_extent_type(path->nodes[0], fi) ==
3172 		    BTRFS_FILE_EXTENT_INLINE)
3173 			set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3174 				&BTRFS_I(inode)->runtime_flags);
3175 	} else {
3176 		em->start = hole_offset;
3177 		em->len = hole_len;
3178 		em->ram_bytes = em->len;
3179 		em->orig_start = hole_offset;
3180 		em->block_start = EXTENT_MAP_HOLE;
3181 		em->block_len = 0;
3182 		em->orig_block_len = 0;
3183 		em->compress_type = BTRFS_COMPRESS_NONE;
3184 		em->generation = trans->transid;
3185 	}
3186 
3187 	while (1) {
3188 		write_lock(&em_tree->lock);
3189 		ret = add_extent_mapping(em_tree, em, 1);
3190 		write_unlock(&em_tree->lock);
3191 		if (ret != -EEXIST) {
3192 			free_extent_map(em);
3193 			break;
3194 		}
3195 		btrfs_drop_extent_cache(inode, em->start,
3196 					em->start + em->len - 1, 0);
3197 	}
3198 
3199 	if (ret)
3200 		set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3201 			&BTRFS_I(inode)->runtime_flags);
3202 }
3203 
3204 /**
3205  * btrfs_clone() - clone a range from inode file to another
3206  *
3207  * @src: Inode to clone from
3208  * @inode: Inode to clone to
3209  * @off: Offset within source to start clone from
3210  * @olen: Original length, passed by user, of range to clone
3211  * @olen_aligned: Block-aligned value of olen, extent_same uses
3212  *               identical values here
3213  * @destoff: Offset within @inode to start clone
3214  */
3215 static int btrfs_clone(struct inode *src, struct inode *inode,
3216 		       const u64 off, const u64 olen, const u64 olen_aligned,
3217 		       const u64 destoff)
3218 {
3219 	struct btrfs_root *root = BTRFS_I(inode)->root;
3220 	struct btrfs_path *path = NULL;
3221 	struct extent_buffer *leaf;
3222 	struct btrfs_trans_handle *trans;
3223 	char *buf = NULL;
3224 	struct btrfs_key key;
3225 	u32 nritems;
3226 	int slot;
3227 	int ret;
3228 	int no_quota;
3229 	const u64 len = olen_aligned;
3230 	u64 last_disko = 0;
3231 	u64 last_dest_end = destoff;
3232 
3233 	ret = -ENOMEM;
3234 	buf = vmalloc(root->nodesize);
3235 	if (!buf)
3236 		return ret;
3237 
3238 	path = btrfs_alloc_path();
3239 	if (!path) {
3240 		vfree(buf);
3241 		return ret;
3242 	}
3243 
3244 	path->reada = 2;
3245 	/* clone data */
3246 	key.objectid = btrfs_ino(src);
3247 	key.type = BTRFS_EXTENT_DATA_KEY;
3248 	key.offset = off;
3249 
3250 	while (1) {
3251 		/*
3252 		 * note the key will change type as we walk through the
3253 		 * tree.
3254 		 */
3255 		path->leave_spinning = 1;
3256 		ret = btrfs_search_slot(NULL, BTRFS_I(src)->root, &key, path,
3257 				0, 0);
3258 		if (ret < 0)
3259 			goto out;
3260 		/*
3261 		 * First search, if no extent item that starts at offset off was
3262 		 * found but the previous item is an extent item, it's possible
3263 		 * it might overlap our target range, therefore process it.
3264 		 */
3265 		if (key.offset == off && ret > 0 && path->slots[0] > 0) {
3266 			btrfs_item_key_to_cpu(path->nodes[0], &key,
3267 					      path->slots[0] - 1);
3268 			if (key.type == BTRFS_EXTENT_DATA_KEY)
3269 				path->slots[0]--;
3270 		}
3271 
3272 		nritems = btrfs_header_nritems(path->nodes[0]);
3273 process_slot:
3274 		no_quota = 1;
3275 		if (path->slots[0] >= nritems) {
3276 			ret = btrfs_next_leaf(BTRFS_I(src)->root, path);
3277 			if (ret < 0)
3278 				goto out;
3279 			if (ret > 0)
3280 				break;
3281 			nritems = btrfs_header_nritems(path->nodes[0]);
3282 		}
3283 		leaf = path->nodes[0];
3284 		slot = path->slots[0];
3285 
3286 		btrfs_item_key_to_cpu(leaf, &key, slot);
3287 		if (key.type > BTRFS_EXTENT_DATA_KEY ||
3288 		    key.objectid != btrfs_ino(src))
3289 			break;
3290 
3291 		if (key.type == BTRFS_EXTENT_DATA_KEY) {
3292 			struct btrfs_file_extent_item *extent;
3293 			int type;
3294 			u32 size;
3295 			struct btrfs_key new_key;
3296 			u64 disko = 0, diskl = 0;
3297 			u64 datao = 0, datal = 0;
3298 			u8 comp;
3299 			u64 drop_start;
3300 
3301 			extent = btrfs_item_ptr(leaf, slot,
3302 						struct btrfs_file_extent_item);
3303 			comp = btrfs_file_extent_compression(leaf, extent);
3304 			type = btrfs_file_extent_type(leaf, extent);
3305 			if (type == BTRFS_FILE_EXTENT_REG ||
3306 			    type == BTRFS_FILE_EXTENT_PREALLOC) {
3307 				disko = btrfs_file_extent_disk_bytenr(leaf,
3308 								      extent);
3309 				diskl = btrfs_file_extent_disk_num_bytes(leaf,
3310 								 extent);
3311 				datao = btrfs_file_extent_offset(leaf, extent);
3312 				datal = btrfs_file_extent_num_bytes(leaf,
3313 								    extent);
3314 			} else if (type == BTRFS_FILE_EXTENT_INLINE) {
3315 				/* take upper bound, may be compressed */
3316 				datal = btrfs_file_extent_ram_bytes(leaf,
3317 								    extent);
3318 			}
3319 
3320 			/*
3321 			 * The first search might have left us at an extent
3322 			 * item that ends before our target range's start, can
3323 			 * happen if we have holes and NO_HOLES feature enabled.
3324 			 */
3325 			if (key.offset + datal <= off) {
3326 				path->slots[0]++;
3327 				goto process_slot;
3328 			} else if (key.offset >= off + len) {
3329 				break;
3330 			}
3331 
3332 			size = btrfs_item_size_nr(leaf, slot);
3333 			read_extent_buffer(leaf, buf,
3334 					   btrfs_item_ptr_offset(leaf, slot),
3335 					   size);
3336 
3337 			btrfs_release_path(path);
3338 			path->leave_spinning = 0;
3339 
3340 			memcpy(&new_key, &key, sizeof(new_key));
3341 			new_key.objectid = btrfs_ino(inode);
3342 			if (off <= key.offset)
3343 				new_key.offset = key.offset + destoff - off;
3344 			else
3345 				new_key.offset = destoff;
3346 
3347 			/*
3348 			 * Deal with a hole that doesn't have an extent item
3349 			 * that represents it (NO_HOLES feature enabled).
3350 			 * This hole is either in the middle of the cloning
3351 			 * range or at the beginning (fully overlaps it or
3352 			 * partially overlaps it).
3353 			 */
3354 			if (new_key.offset != last_dest_end)
3355 				drop_start = last_dest_end;
3356 			else
3357 				drop_start = new_key.offset;
3358 
3359 			/*
3360 			 * 1 - adjusting old extent (we may have to split it)
3361 			 * 1 - add new extent
3362 			 * 1 - inode update
3363 			 */
3364 			trans = btrfs_start_transaction(root, 3);
3365 			if (IS_ERR(trans)) {
3366 				ret = PTR_ERR(trans);
3367 				goto out;
3368 			}
3369 
3370 			if (type == BTRFS_FILE_EXTENT_REG ||
3371 			    type == BTRFS_FILE_EXTENT_PREALLOC) {
3372 				/*
3373 				 *    a  | --- range to clone ---|  b
3374 				 * | ------------- extent ------------- |
3375 				 */
3376 
3377 				/* subtract range b */
3378 				if (key.offset + datal > off + len)
3379 					datal = off + len - key.offset;
3380 
3381 				/* subtract range a */
3382 				if (off > key.offset) {
3383 					datao += off - key.offset;
3384 					datal -= off - key.offset;
3385 				}
3386 
3387 				ret = btrfs_drop_extents(trans, root, inode,
3388 							 drop_start,
3389 							 new_key.offset + datal,
3390 							 1);
3391 				if (ret) {
3392 					if (ret != -EOPNOTSUPP)
3393 						btrfs_abort_transaction(trans,
3394 								root, ret);
3395 					btrfs_end_transaction(trans, root);
3396 					goto out;
3397 				}
3398 
3399 				ret = btrfs_insert_empty_item(trans, root, path,
3400 							      &new_key, size);
3401 				if (ret) {
3402 					btrfs_abort_transaction(trans, root,
3403 								ret);
3404 					btrfs_end_transaction(trans, root);
3405 					goto out;
3406 				}
3407 
3408 				leaf = path->nodes[0];
3409 				slot = path->slots[0];
3410 				write_extent_buffer(leaf, buf,
3411 					    btrfs_item_ptr_offset(leaf, slot),
3412 					    size);
3413 
3414 				extent = btrfs_item_ptr(leaf, slot,
3415 						struct btrfs_file_extent_item);
3416 
3417 				/* disko == 0 means it's a hole */
3418 				if (!disko)
3419 					datao = 0;
3420 
3421 				btrfs_set_file_extent_offset(leaf, extent,
3422 							     datao);
3423 				btrfs_set_file_extent_num_bytes(leaf, extent,
3424 								datal);
3425 
3426 				/*
3427 				 * We need to look up the roots that point at
3428 				 * this bytenr and see if the new root does.  If
3429 				 * it does not we need to make sure we update
3430 				 * quotas appropriately.
3431 				 */
3432 				if (disko && root != BTRFS_I(src)->root &&
3433 				    disko != last_disko) {
3434 					no_quota = check_ref(trans, root,
3435 							     disko);
3436 					if (no_quota < 0) {
3437 						btrfs_abort_transaction(trans,
3438 									root,
3439 									ret);
3440 						btrfs_end_transaction(trans,
3441 								      root);
3442 						ret = no_quota;
3443 						goto out;
3444 					}
3445 				}
3446 
3447 				if (disko) {
3448 					inode_add_bytes(inode, datal);
3449 					ret = btrfs_inc_extent_ref(trans, root,
3450 							disko, diskl, 0,
3451 							root->root_key.objectid,
3452 							btrfs_ino(inode),
3453 							new_key.offset - datao,
3454 							no_quota);
3455 					if (ret) {
3456 						btrfs_abort_transaction(trans,
3457 									root,
3458 									ret);
3459 						btrfs_end_transaction(trans,
3460 								      root);
3461 						goto out;
3462 
3463 					}
3464 				}
3465 			} else if (type == BTRFS_FILE_EXTENT_INLINE) {
3466 				u64 skip = 0;
3467 				u64 trim = 0;
3468 				u64 aligned_end = 0;
3469 
3470 				if (off > key.offset) {
3471 					skip = off - key.offset;
3472 					new_key.offset += skip;
3473 				}
3474 
3475 				if (key.offset + datal > off + len)
3476 					trim = key.offset + datal - (off + len);
3477 
3478 				if (comp && (skip || trim)) {
3479 					ret = -EINVAL;
3480 					btrfs_end_transaction(trans, root);
3481 					goto out;
3482 				}
3483 				size -= skip + trim;
3484 				datal -= skip + trim;
3485 
3486 				aligned_end = ALIGN(new_key.offset + datal,
3487 						    root->sectorsize);
3488 				ret = btrfs_drop_extents(trans, root, inode,
3489 							 drop_start,
3490 							 aligned_end,
3491 							 1);
3492 				if (ret) {
3493 					if (ret != -EOPNOTSUPP)
3494 						btrfs_abort_transaction(trans,
3495 							root, ret);
3496 					btrfs_end_transaction(trans, root);
3497 					goto out;
3498 				}
3499 
3500 				ret = btrfs_insert_empty_item(trans, root, path,
3501 							      &new_key, size);
3502 				if (ret) {
3503 					btrfs_abort_transaction(trans, root,
3504 								ret);
3505 					btrfs_end_transaction(trans, root);
3506 					goto out;
3507 				}
3508 
3509 				if (skip) {
3510 					u32 start =
3511 					  btrfs_file_extent_calc_inline_size(0);
3512 					memmove(buf+start, buf+start+skip,
3513 						datal);
3514 				}
3515 
3516 				leaf = path->nodes[0];
3517 				slot = path->slots[0];
3518 				write_extent_buffer(leaf, buf,
3519 					    btrfs_item_ptr_offset(leaf, slot),
3520 					    size);
3521 				inode_add_bytes(inode, datal);
3522 			}
3523 
3524 			/* If we have an implicit hole (NO_HOLES feature). */
3525 			if (drop_start < new_key.offset)
3526 				clone_update_extent_map(inode, trans,
3527 						NULL, drop_start,
3528 						new_key.offset - drop_start);
3529 
3530 			clone_update_extent_map(inode, trans, path, 0, 0);
3531 
3532 			btrfs_mark_buffer_dirty(leaf);
3533 			btrfs_release_path(path);
3534 
3535 			last_dest_end = ALIGN(new_key.offset + datal,
3536 					      root->sectorsize);
3537 			ret = clone_finish_inode_update(trans, inode,
3538 							last_dest_end,
3539 							destoff, olen);
3540 			if (ret)
3541 				goto out;
3542 			if (new_key.offset + datal >= destoff + len)
3543 				break;
3544 		}
3545 		btrfs_release_path(path);
3546 		key.offset++;
3547 	}
3548 	ret = 0;
3549 
3550 	if (last_dest_end < destoff + len) {
3551 		/*
3552 		 * We have an implicit hole (NO_HOLES feature is enabled) that
3553 		 * fully or partially overlaps our cloning range at its end.
3554 		 */
3555 		btrfs_release_path(path);
3556 
3557 		/*
3558 		 * 1 - remove extent(s)
3559 		 * 1 - inode update
3560 		 */
3561 		trans = btrfs_start_transaction(root, 2);
3562 		if (IS_ERR(trans)) {
3563 			ret = PTR_ERR(trans);
3564 			goto out;
3565 		}
3566 		ret = btrfs_drop_extents(trans, root, inode,
3567 					 last_dest_end, destoff + len, 1);
3568 		if (ret) {
3569 			if (ret != -EOPNOTSUPP)
3570 				btrfs_abort_transaction(trans, root, ret);
3571 			btrfs_end_transaction(trans, root);
3572 			goto out;
3573 		}
3574 		clone_update_extent_map(inode, trans, NULL, last_dest_end,
3575 					destoff + len - last_dest_end);
3576 		ret = clone_finish_inode_update(trans, inode, destoff + len,
3577 						destoff, olen);
3578 	}
3579 
3580 out:
3581 	btrfs_free_path(path);
3582 	vfree(buf);
3583 	return ret;
3584 }
3585 
3586 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
3587 				       u64 off, u64 olen, u64 destoff)
3588 {
3589 	struct inode *inode = file_inode(file);
3590 	struct btrfs_root *root = BTRFS_I(inode)->root;
3591 	struct fd src_file;
3592 	struct inode *src;
3593 	int ret;
3594 	u64 len = olen;
3595 	u64 bs = root->fs_info->sb->s_blocksize;
3596 	int same_inode = 0;
3597 
3598 	/*
3599 	 * TODO:
3600 	 * - split compressed inline extents.  annoying: we need to
3601 	 *   decompress into destination's address_space (the file offset
3602 	 *   may change, so source mapping won't do), then recompress (or
3603 	 *   otherwise reinsert) a subrange.
3604 	 *
3605 	 * - split destination inode's inline extents.  The inline extents can
3606 	 *   be either compressed or non-compressed.
3607 	 */
3608 
3609 	/* the destination must be opened for writing */
3610 	if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND))
3611 		return -EINVAL;
3612 
3613 	if (btrfs_root_readonly(root))
3614 		return -EROFS;
3615 
3616 	ret = mnt_want_write_file(file);
3617 	if (ret)
3618 		return ret;
3619 
3620 	src_file = fdget(srcfd);
3621 	if (!src_file.file) {
3622 		ret = -EBADF;
3623 		goto out_drop_write;
3624 	}
3625 
3626 	ret = -EXDEV;
3627 	if (src_file.file->f_path.mnt != file->f_path.mnt)
3628 		goto out_fput;
3629 
3630 	src = file_inode(src_file.file);
3631 
3632 	ret = -EINVAL;
3633 	if (src == inode)
3634 		same_inode = 1;
3635 
3636 	/* the src must be open for reading */
3637 	if (!(src_file.file->f_mode & FMODE_READ))
3638 		goto out_fput;
3639 
3640 	/* don't make the dst file partly checksummed */
3641 	if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
3642 	    (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
3643 		goto out_fput;
3644 
3645 	ret = -EISDIR;
3646 	if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
3647 		goto out_fput;
3648 
3649 	ret = -EXDEV;
3650 	if (src->i_sb != inode->i_sb)
3651 		goto out_fput;
3652 
3653 	if (!same_inode) {
3654 		if (inode < src) {
3655 			mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
3656 			mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD);
3657 		} else {
3658 			mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT);
3659 			mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
3660 		}
3661 	} else {
3662 		mutex_lock(&src->i_mutex);
3663 	}
3664 
3665 	/* determine range to clone */
3666 	ret = -EINVAL;
3667 	if (off + len > src->i_size || off + len < off)
3668 		goto out_unlock;
3669 	if (len == 0)
3670 		olen = len = src->i_size - off;
3671 	/* if we extend to eof, continue to block boundary */
3672 	if (off + len == src->i_size)
3673 		len = ALIGN(src->i_size, bs) - off;
3674 
3675 	/* verify the end result is block aligned */
3676 	if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) ||
3677 	    !IS_ALIGNED(destoff, bs))
3678 		goto out_unlock;
3679 
3680 	/* verify if ranges are overlapped within the same file */
3681 	if (same_inode) {
3682 		if (destoff + len > off && destoff < off + len)
3683 			goto out_unlock;
3684 	}
3685 
3686 	if (destoff > inode->i_size) {
3687 		ret = btrfs_cont_expand(inode, inode->i_size, destoff);
3688 		if (ret)
3689 			goto out_unlock;
3690 	}
3691 
3692 	/*
3693 	 * Lock the target range too. Right after we replace the file extent
3694 	 * items in the fs tree (which now point to the cloned data), we might
3695 	 * have a worker replace them with extent items relative to a write
3696 	 * operation that was issued before this clone operation (i.e. confront
3697 	 * with inode.c:btrfs_finish_ordered_io).
3698 	 */
3699 	if (same_inode) {
3700 		u64 lock_start = min_t(u64, off, destoff);
3701 		u64 lock_len = max_t(u64, off, destoff) + len - lock_start;
3702 
3703 		lock_extent_range(src, lock_start, lock_len);
3704 	} else {
3705 		lock_extent_range(src, off, len);
3706 		lock_extent_range(inode, destoff, len);
3707 	}
3708 
3709 	ret = btrfs_clone(src, inode, off, olen, len, destoff);
3710 
3711 	if (same_inode) {
3712 		u64 lock_start = min_t(u64, off, destoff);
3713 		u64 lock_end = max_t(u64, off, destoff) + len - 1;
3714 
3715 		unlock_extent(&BTRFS_I(src)->io_tree, lock_start, lock_end);
3716 	} else {
3717 		unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
3718 		unlock_extent(&BTRFS_I(inode)->io_tree, destoff,
3719 			      destoff + len - 1);
3720 	}
3721 	/*
3722 	 * Truncate page cache pages so that future reads will see the cloned
3723 	 * data immediately and not the previous data.
3724 	 */
3725 	truncate_inode_pages_range(&inode->i_data, destoff,
3726 				   PAGE_CACHE_ALIGN(destoff + len) - 1);
3727 out_unlock:
3728 	if (!same_inode) {
3729 		if (inode < src) {
3730 			mutex_unlock(&src->i_mutex);
3731 			mutex_unlock(&inode->i_mutex);
3732 		} else {
3733 			mutex_unlock(&inode->i_mutex);
3734 			mutex_unlock(&src->i_mutex);
3735 		}
3736 	} else {
3737 		mutex_unlock(&src->i_mutex);
3738 	}
3739 out_fput:
3740 	fdput(src_file);
3741 out_drop_write:
3742 	mnt_drop_write_file(file);
3743 	return ret;
3744 }
3745 
3746 static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
3747 {
3748 	struct btrfs_ioctl_clone_range_args args;
3749 
3750 	if (copy_from_user(&args, argp, sizeof(args)))
3751 		return -EFAULT;
3752 	return btrfs_ioctl_clone(file, args.src_fd, args.src_offset,
3753 				 args.src_length, args.dest_offset);
3754 }
3755 
3756 /*
3757  * there are many ways the trans_start and trans_end ioctls can lead
3758  * to deadlocks.  They should only be used by applications that
3759  * basically own the machine, and have a very in depth understanding
3760  * of all the possible deadlocks and enospc problems.
3761  */
3762 static long btrfs_ioctl_trans_start(struct file *file)
3763 {
3764 	struct inode *inode = file_inode(file);
3765 	struct btrfs_root *root = BTRFS_I(inode)->root;
3766 	struct btrfs_trans_handle *trans;
3767 	int ret;
3768 
3769 	ret = -EPERM;
3770 	if (!capable(CAP_SYS_ADMIN))
3771 		goto out;
3772 
3773 	ret = -EINPROGRESS;
3774 	if (file->private_data)
3775 		goto out;
3776 
3777 	ret = -EROFS;
3778 	if (btrfs_root_readonly(root))
3779 		goto out;
3780 
3781 	ret = mnt_want_write_file(file);
3782 	if (ret)
3783 		goto out;
3784 
3785 	atomic_inc(&root->fs_info->open_ioctl_trans);
3786 
3787 	ret = -ENOMEM;
3788 	trans = btrfs_start_ioctl_transaction(root);
3789 	if (IS_ERR(trans))
3790 		goto out_drop;
3791 
3792 	file->private_data = trans;
3793 	return 0;
3794 
3795 out_drop:
3796 	atomic_dec(&root->fs_info->open_ioctl_trans);
3797 	mnt_drop_write_file(file);
3798 out:
3799 	return ret;
3800 }
3801 
3802 static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
3803 {
3804 	struct inode *inode = file_inode(file);
3805 	struct btrfs_root *root = BTRFS_I(inode)->root;
3806 	struct btrfs_root *new_root;
3807 	struct btrfs_dir_item *di;
3808 	struct btrfs_trans_handle *trans;
3809 	struct btrfs_path *path;
3810 	struct btrfs_key location;
3811 	struct btrfs_disk_key disk_key;
3812 	u64 objectid = 0;
3813 	u64 dir_id;
3814 	int ret;
3815 
3816 	if (!capable(CAP_SYS_ADMIN))
3817 		return -EPERM;
3818 
3819 	ret = mnt_want_write_file(file);
3820 	if (ret)
3821 		return ret;
3822 
3823 	if (copy_from_user(&objectid, argp, sizeof(objectid))) {
3824 		ret = -EFAULT;
3825 		goto out;
3826 	}
3827 
3828 	if (!objectid)
3829 		objectid = BTRFS_FS_TREE_OBJECTID;
3830 
3831 	location.objectid = objectid;
3832 	location.type = BTRFS_ROOT_ITEM_KEY;
3833 	location.offset = (u64)-1;
3834 
3835 	new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
3836 	if (IS_ERR(new_root)) {
3837 		ret = PTR_ERR(new_root);
3838 		goto out;
3839 	}
3840 
3841 	path = btrfs_alloc_path();
3842 	if (!path) {
3843 		ret = -ENOMEM;
3844 		goto out;
3845 	}
3846 	path->leave_spinning = 1;
3847 
3848 	trans = btrfs_start_transaction(root, 1);
3849 	if (IS_ERR(trans)) {
3850 		btrfs_free_path(path);
3851 		ret = PTR_ERR(trans);
3852 		goto out;
3853 	}
3854 
3855 	dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
3856 	di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path,
3857 				   dir_id, "default", 7, 1);
3858 	if (IS_ERR_OR_NULL(di)) {
3859 		btrfs_free_path(path);
3860 		btrfs_end_transaction(trans, root);
3861 		btrfs_err(new_root->fs_info, "Umm, you don't have the default dir"
3862 			   "item, this isn't going to work");
3863 		ret = -ENOENT;
3864 		goto out;
3865 	}
3866 
3867 	btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
3868 	btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
3869 	btrfs_mark_buffer_dirty(path->nodes[0]);
3870 	btrfs_free_path(path);
3871 
3872 	btrfs_set_fs_incompat(root->fs_info, DEFAULT_SUBVOL);
3873 	btrfs_end_transaction(trans, root);
3874 out:
3875 	mnt_drop_write_file(file);
3876 	return ret;
3877 }
3878 
3879 void btrfs_get_block_group_info(struct list_head *groups_list,
3880 				struct btrfs_ioctl_space_info *space)
3881 {
3882 	struct btrfs_block_group_cache *block_group;
3883 
3884 	space->total_bytes = 0;
3885 	space->used_bytes = 0;
3886 	space->flags = 0;
3887 	list_for_each_entry(block_group, groups_list, list) {
3888 		space->flags = block_group->flags;
3889 		space->total_bytes += block_group->key.offset;
3890 		space->used_bytes +=
3891 			btrfs_block_group_used(&block_group->item);
3892 	}
3893 }
3894 
3895 static long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
3896 {
3897 	struct btrfs_ioctl_space_args space_args;
3898 	struct btrfs_ioctl_space_info space;
3899 	struct btrfs_ioctl_space_info *dest;
3900 	struct btrfs_ioctl_space_info *dest_orig;
3901 	struct btrfs_ioctl_space_info __user *user_dest;
3902 	struct btrfs_space_info *info;
3903 	u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
3904 		       BTRFS_BLOCK_GROUP_SYSTEM,
3905 		       BTRFS_BLOCK_GROUP_METADATA,
3906 		       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
3907 	int num_types = 4;
3908 	int alloc_size;
3909 	int ret = 0;
3910 	u64 slot_count = 0;
3911 	int i, c;
3912 
3913 	if (copy_from_user(&space_args,
3914 			   (struct btrfs_ioctl_space_args __user *)arg,
3915 			   sizeof(space_args)))
3916 		return -EFAULT;
3917 
3918 	for (i = 0; i < num_types; i++) {
3919 		struct btrfs_space_info *tmp;
3920 
3921 		info = NULL;
3922 		rcu_read_lock();
3923 		list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
3924 					list) {
3925 			if (tmp->flags == types[i]) {
3926 				info = tmp;
3927 				break;
3928 			}
3929 		}
3930 		rcu_read_unlock();
3931 
3932 		if (!info)
3933 			continue;
3934 
3935 		down_read(&info->groups_sem);
3936 		for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3937 			if (!list_empty(&info->block_groups[c]))
3938 				slot_count++;
3939 		}
3940 		up_read(&info->groups_sem);
3941 	}
3942 
3943 	/*
3944 	 * Global block reserve, exported as a space_info
3945 	 */
3946 	slot_count++;
3947 
3948 	/* space_slots == 0 means they are asking for a count */
3949 	if (space_args.space_slots == 0) {
3950 		space_args.total_spaces = slot_count;
3951 		goto out;
3952 	}
3953 
3954 	slot_count = min_t(u64, space_args.space_slots, slot_count);
3955 
3956 	alloc_size = sizeof(*dest) * slot_count;
3957 
3958 	/* we generally have at most 6 or so space infos, one for each raid
3959 	 * level.  So, a whole page should be more than enough for everyone
3960 	 */
3961 	if (alloc_size > PAGE_CACHE_SIZE)
3962 		return -ENOMEM;
3963 
3964 	space_args.total_spaces = 0;
3965 	dest = kmalloc(alloc_size, GFP_NOFS);
3966 	if (!dest)
3967 		return -ENOMEM;
3968 	dest_orig = dest;
3969 
3970 	/* now we have a buffer to copy into */
3971 	for (i = 0; i < num_types; i++) {
3972 		struct btrfs_space_info *tmp;
3973 
3974 		if (!slot_count)
3975 			break;
3976 
3977 		info = NULL;
3978 		rcu_read_lock();
3979 		list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
3980 					list) {
3981 			if (tmp->flags == types[i]) {
3982 				info = tmp;
3983 				break;
3984 			}
3985 		}
3986 		rcu_read_unlock();
3987 
3988 		if (!info)
3989 			continue;
3990 		down_read(&info->groups_sem);
3991 		for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3992 			if (!list_empty(&info->block_groups[c])) {
3993 				btrfs_get_block_group_info(
3994 					&info->block_groups[c], &space);
3995 				memcpy(dest, &space, sizeof(space));
3996 				dest++;
3997 				space_args.total_spaces++;
3998 				slot_count--;
3999 			}
4000 			if (!slot_count)
4001 				break;
4002 		}
4003 		up_read(&info->groups_sem);
4004 	}
4005 
4006 	/*
4007 	 * Add global block reserve
4008 	 */
4009 	if (slot_count) {
4010 		struct btrfs_block_rsv *block_rsv = &root->fs_info->global_block_rsv;
4011 
4012 		spin_lock(&block_rsv->lock);
4013 		space.total_bytes = block_rsv->size;
4014 		space.used_bytes = block_rsv->size - block_rsv->reserved;
4015 		spin_unlock(&block_rsv->lock);
4016 		space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV;
4017 		memcpy(dest, &space, sizeof(space));
4018 		space_args.total_spaces++;
4019 	}
4020 
4021 	user_dest = (struct btrfs_ioctl_space_info __user *)
4022 		(arg + sizeof(struct btrfs_ioctl_space_args));
4023 
4024 	if (copy_to_user(user_dest, dest_orig, alloc_size))
4025 		ret = -EFAULT;
4026 
4027 	kfree(dest_orig);
4028 out:
4029 	if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
4030 		ret = -EFAULT;
4031 
4032 	return ret;
4033 }
4034 
4035 /*
4036  * there are many ways the trans_start and trans_end ioctls can lead
4037  * to deadlocks.  They should only be used by applications that
4038  * basically own the machine, and have a very in depth understanding
4039  * of all the possible deadlocks and enospc problems.
4040  */
4041 long btrfs_ioctl_trans_end(struct file *file)
4042 {
4043 	struct inode *inode = file_inode(file);
4044 	struct btrfs_root *root = BTRFS_I(inode)->root;
4045 	struct btrfs_trans_handle *trans;
4046 
4047 	trans = file->private_data;
4048 	if (!trans)
4049 		return -EINVAL;
4050 	file->private_data = NULL;
4051 
4052 	btrfs_end_transaction(trans, root);
4053 
4054 	atomic_dec(&root->fs_info->open_ioctl_trans);
4055 
4056 	mnt_drop_write_file(file);
4057 	return 0;
4058 }
4059 
4060 static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
4061 					    void __user *argp)
4062 {
4063 	struct btrfs_trans_handle *trans;
4064 	u64 transid;
4065 	int ret;
4066 
4067 	trans = btrfs_attach_transaction_barrier(root);
4068 	if (IS_ERR(trans)) {
4069 		if (PTR_ERR(trans) != -ENOENT)
4070 			return PTR_ERR(trans);
4071 
4072 		/* No running transaction, don't bother */
4073 		transid = root->fs_info->last_trans_committed;
4074 		goto out;
4075 	}
4076 	transid = trans->transid;
4077 	ret = btrfs_commit_transaction_async(trans, root, 0);
4078 	if (ret) {
4079 		btrfs_end_transaction(trans, root);
4080 		return ret;
4081 	}
4082 out:
4083 	if (argp)
4084 		if (copy_to_user(argp, &transid, sizeof(transid)))
4085 			return -EFAULT;
4086 	return 0;
4087 }
4088 
4089 static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root,
4090 					   void __user *argp)
4091 {
4092 	u64 transid;
4093 
4094 	if (argp) {
4095 		if (copy_from_user(&transid, argp, sizeof(transid)))
4096 			return -EFAULT;
4097 	} else {
4098 		transid = 0;  /* current trans */
4099 	}
4100 	return btrfs_wait_for_commit(root, transid);
4101 }
4102 
4103 static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
4104 {
4105 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4106 	struct btrfs_ioctl_scrub_args *sa;
4107 	int ret;
4108 
4109 	if (!capable(CAP_SYS_ADMIN))
4110 		return -EPERM;
4111 
4112 	sa = memdup_user(arg, sizeof(*sa));
4113 	if (IS_ERR(sa))
4114 		return PTR_ERR(sa);
4115 
4116 	if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
4117 		ret = mnt_want_write_file(file);
4118 		if (ret)
4119 			goto out;
4120 	}
4121 
4122 	ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end,
4123 			      &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
4124 			      0);
4125 
4126 	if (copy_to_user(arg, sa, sizeof(*sa)))
4127 		ret = -EFAULT;
4128 
4129 	if (!(sa->flags & BTRFS_SCRUB_READONLY))
4130 		mnt_drop_write_file(file);
4131 out:
4132 	kfree(sa);
4133 	return ret;
4134 }
4135 
4136 static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
4137 {
4138 	if (!capable(CAP_SYS_ADMIN))
4139 		return -EPERM;
4140 
4141 	return btrfs_scrub_cancel(root->fs_info);
4142 }
4143 
4144 static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
4145 				       void __user *arg)
4146 {
4147 	struct btrfs_ioctl_scrub_args *sa;
4148 	int ret;
4149 
4150 	if (!capable(CAP_SYS_ADMIN))
4151 		return -EPERM;
4152 
4153 	sa = memdup_user(arg, sizeof(*sa));
4154 	if (IS_ERR(sa))
4155 		return PTR_ERR(sa);
4156 
4157 	ret = btrfs_scrub_progress(root, sa->devid, &sa->progress);
4158 
4159 	if (copy_to_user(arg, sa, sizeof(*sa)))
4160 		ret = -EFAULT;
4161 
4162 	kfree(sa);
4163 	return ret;
4164 }
4165 
4166 static long btrfs_ioctl_get_dev_stats(struct btrfs_root *root,
4167 				      void __user *arg)
4168 {
4169 	struct btrfs_ioctl_get_dev_stats *sa;
4170 	int ret;
4171 
4172 	sa = memdup_user(arg, sizeof(*sa));
4173 	if (IS_ERR(sa))
4174 		return PTR_ERR(sa);
4175 
4176 	if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) {
4177 		kfree(sa);
4178 		return -EPERM;
4179 	}
4180 
4181 	ret = btrfs_get_dev_stats(root, sa);
4182 
4183 	if (copy_to_user(arg, sa, sizeof(*sa)))
4184 		ret = -EFAULT;
4185 
4186 	kfree(sa);
4187 	return ret;
4188 }
4189 
4190 static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
4191 {
4192 	struct btrfs_ioctl_dev_replace_args *p;
4193 	int ret;
4194 
4195 	if (!capable(CAP_SYS_ADMIN))
4196 		return -EPERM;
4197 
4198 	p = memdup_user(arg, sizeof(*p));
4199 	if (IS_ERR(p))
4200 		return PTR_ERR(p);
4201 
4202 	switch (p->cmd) {
4203 	case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
4204 		if (root->fs_info->sb->s_flags & MS_RDONLY) {
4205 			ret = -EROFS;
4206 			goto out;
4207 		}
4208 		if (atomic_xchg(
4209 			&root->fs_info->mutually_exclusive_operation_running,
4210 			1)) {
4211 			ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
4212 		} else {
4213 			ret = btrfs_dev_replace_start(root, p);
4214 			atomic_set(
4215 			 &root->fs_info->mutually_exclusive_operation_running,
4216 			 0);
4217 		}
4218 		break;
4219 	case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
4220 		btrfs_dev_replace_status(root->fs_info, p);
4221 		ret = 0;
4222 		break;
4223 	case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
4224 		ret = btrfs_dev_replace_cancel(root->fs_info, p);
4225 		break;
4226 	default:
4227 		ret = -EINVAL;
4228 		break;
4229 	}
4230 
4231 	if (copy_to_user(arg, p, sizeof(*p)))
4232 		ret = -EFAULT;
4233 out:
4234 	kfree(p);
4235 	return ret;
4236 }
4237 
4238 static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
4239 {
4240 	int ret = 0;
4241 	int i;
4242 	u64 rel_ptr;
4243 	int size;
4244 	struct btrfs_ioctl_ino_path_args *ipa = NULL;
4245 	struct inode_fs_paths *ipath = NULL;
4246 	struct btrfs_path *path;
4247 
4248 	if (!capable(CAP_DAC_READ_SEARCH))
4249 		return -EPERM;
4250 
4251 	path = btrfs_alloc_path();
4252 	if (!path) {
4253 		ret = -ENOMEM;
4254 		goto out;
4255 	}
4256 
4257 	ipa = memdup_user(arg, sizeof(*ipa));
4258 	if (IS_ERR(ipa)) {
4259 		ret = PTR_ERR(ipa);
4260 		ipa = NULL;
4261 		goto out;
4262 	}
4263 
4264 	size = min_t(u32, ipa->size, 4096);
4265 	ipath = init_ipath(size, root, path);
4266 	if (IS_ERR(ipath)) {
4267 		ret = PTR_ERR(ipath);
4268 		ipath = NULL;
4269 		goto out;
4270 	}
4271 
4272 	ret = paths_from_inode(ipa->inum, ipath);
4273 	if (ret < 0)
4274 		goto out;
4275 
4276 	for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
4277 		rel_ptr = ipath->fspath->val[i] -
4278 			  (u64)(unsigned long)ipath->fspath->val;
4279 		ipath->fspath->val[i] = rel_ptr;
4280 	}
4281 
4282 	ret = copy_to_user((void *)(unsigned long)ipa->fspath,
4283 			   (void *)(unsigned long)ipath->fspath, size);
4284 	if (ret) {
4285 		ret = -EFAULT;
4286 		goto out;
4287 	}
4288 
4289 out:
4290 	btrfs_free_path(path);
4291 	free_ipath(ipath);
4292 	kfree(ipa);
4293 
4294 	return ret;
4295 }
4296 
4297 static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx)
4298 {
4299 	struct btrfs_data_container *inodes = ctx;
4300 	const size_t c = 3 * sizeof(u64);
4301 
4302 	if (inodes->bytes_left >= c) {
4303 		inodes->bytes_left -= c;
4304 		inodes->val[inodes->elem_cnt] = inum;
4305 		inodes->val[inodes->elem_cnt + 1] = offset;
4306 		inodes->val[inodes->elem_cnt + 2] = root;
4307 		inodes->elem_cnt += 3;
4308 	} else {
4309 		inodes->bytes_missing += c - inodes->bytes_left;
4310 		inodes->bytes_left = 0;
4311 		inodes->elem_missed += 3;
4312 	}
4313 
4314 	return 0;
4315 }
4316 
4317 static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
4318 					void __user *arg)
4319 {
4320 	int ret = 0;
4321 	int size;
4322 	struct btrfs_ioctl_logical_ino_args *loi;
4323 	struct btrfs_data_container *inodes = NULL;
4324 	struct btrfs_path *path = NULL;
4325 
4326 	if (!capable(CAP_SYS_ADMIN))
4327 		return -EPERM;
4328 
4329 	loi = memdup_user(arg, sizeof(*loi));
4330 	if (IS_ERR(loi)) {
4331 		ret = PTR_ERR(loi);
4332 		loi = NULL;
4333 		goto out;
4334 	}
4335 
4336 	path = btrfs_alloc_path();
4337 	if (!path) {
4338 		ret = -ENOMEM;
4339 		goto out;
4340 	}
4341 
4342 	size = min_t(u32, loi->size, 64 * 1024);
4343 	inodes = init_data_container(size);
4344 	if (IS_ERR(inodes)) {
4345 		ret = PTR_ERR(inodes);
4346 		inodes = NULL;
4347 		goto out;
4348 	}
4349 
4350 	ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path,
4351 					  build_ino_list, inodes);
4352 	if (ret == -EINVAL)
4353 		ret = -ENOENT;
4354 	if (ret < 0)
4355 		goto out;
4356 
4357 	ret = copy_to_user((void *)(unsigned long)loi->inodes,
4358 			   (void *)(unsigned long)inodes, size);
4359 	if (ret)
4360 		ret = -EFAULT;
4361 
4362 out:
4363 	btrfs_free_path(path);
4364 	vfree(inodes);
4365 	kfree(loi);
4366 
4367 	return ret;
4368 }
4369 
4370 void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
4371 			       struct btrfs_ioctl_balance_args *bargs)
4372 {
4373 	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
4374 
4375 	bargs->flags = bctl->flags;
4376 
4377 	if (atomic_read(&fs_info->balance_running))
4378 		bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
4379 	if (atomic_read(&fs_info->balance_pause_req))
4380 		bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
4381 	if (atomic_read(&fs_info->balance_cancel_req))
4382 		bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
4383 
4384 	memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
4385 	memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
4386 	memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
4387 
4388 	if (lock) {
4389 		spin_lock(&fs_info->balance_lock);
4390 		memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
4391 		spin_unlock(&fs_info->balance_lock);
4392 	} else {
4393 		memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
4394 	}
4395 }
4396 
4397 static long btrfs_ioctl_balance(struct file *file, void __user *arg)
4398 {
4399 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4400 	struct btrfs_fs_info *fs_info = root->fs_info;
4401 	struct btrfs_ioctl_balance_args *bargs;
4402 	struct btrfs_balance_control *bctl;
4403 	bool need_unlock; /* for mut. excl. ops lock */
4404 	int ret;
4405 
4406 	if (!capable(CAP_SYS_ADMIN))
4407 		return -EPERM;
4408 
4409 	ret = mnt_want_write_file(file);
4410 	if (ret)
4411 		return ret;
4412 
4413 again:
4414 	if (!atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1)) {
4415 		mutex_lock(&fs_info->volume_mutex);
4416 		mutex_lock(&fs_info->balance_mutex);
4417 		need_unlock = true;
4418 		goto locked;
4419 	}
4420 
4421 	/*
4422 	 * mut. excl. ops lock is locked.  Three possibilites:
4423 	 *   (1) some other op is running
4424 	 *   (2) balance is running
4425 	 *   (3) balance is paused -- special case (think resume)
4426 	 */
4427 	mutex_lock(&fs_info->balance_mutex);
4428 	if (fs_info->balance_ctl) {
4429 		/* this is either (2) or (3) */
4430 		if (!atomic_read(&fs_info->balance_running)) {
4431 			mutex_unlock(&fs_info->balance_mutex);
4432 			if (!mutex_trylock(&fs_info->volume_mutex))
4433 				goto again;
4434 			mutex_lock(&fs_info->balance_mutex);
4435 
4436 			if (fs_info->balance_ctl &&
4437 			    !atomic_read(&fs_info->balance_running)) {
4438 				/* this is (3) */
4439 				need_unlock = false;
4440 				goto locked;
4441 			}
4442 
4443 			mutex_unlock(&fs_info->balance_mutex);
4444 			mutex_unlock(&fs_info->volume_mutex);
4445 			goto again;
4446 		} else {
4447 			/* this is (2) */
4448 			mutex_unlock(&fs_info->balance_mutex);
4449 			ret = -EINPROGRESS;
4450 			goto out;
4451 		}
4452 	} else {
4453 		/* this is (1) */
4454 		mutex_unlock(&fs_info->balance_mutex);
4455 		ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
4456 		goto out;
4457 	}
4458 
4459 locked:
4460 	BUG_ON(!atomic_read(&fs_info->mutually_exclusive_operation_running));
4461 
4462 	if (arg) {
4463 		bargs = memdup_user(arg, sizeof(*bargs));
4464 		if (IS_ERR(bargs)) {
4465 			ret = PTR_ERR(bargs);
4466 			goto out_unlock;
4467 		}
4468 
4469 		if (bargs->flags & BTRFS_BALANCE_RESUME) {
4470 			if (!fs_info->balance_ctl) {
4471 				ret = -ENOTCONN;
4472 				goto out_bargs;
4473 			}
4474 
4475 			bctl = fs_info->balance_ctl;
4476 			spin_lock(&fs_info->balance_lock);
4477 			bctl->flags |= BTRFS_BALANCE_RESUME;
4478 			spin_unlock(&fs_info->balance_lock);
4479 
4480 			goto do_balance;
4481 		}
4482 	} else {
4483 		bargs = NULL;
4484 	}
4485 
4486 	if (fs_info->balance_ctl) {
4487 		ret = -EINPROGRESS;
4488 		goto out_bargs;
4489 	}
4490 
4491 	bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
4492 	if (!bctl) {
4493 		ret = -ENOMEM;
4494 		goto out_bargs;
4495 	}
4496 
4497 	bctl->fs_info = fs_info;
4498 	if (arg) {
4499 		memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
4500 		memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
4501 		memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));
4502 
4503 		bctl->flags = bargs->flags;
4504 	} else {
4505 		/* balance everything - no filters */
4506 		bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
4507 	}
4508 
4509 do_balance:
4510 	/*
4511 	 * Ownership of bctl and mutually_exclusive_operation_running
4512 	 * goes to to btrfs_balance.  bctl is freed in __cancel_balance,
4513 	 * or, if restriper was paused all the way until unmount, in
4514 	 * free_fs_info.  mutually_exclusive_operation_running is
4515 	 * cleared in __cancel_balance.
4516 	 */
4517 	need_unlock = false;
4518 
4519 	ret = btrfs_balance(bctl, bargs);
4520 
4521 	if (arg) {
4522 		if (copy_to_user(arg, bargs, sizeof(*bargs)))
4523 			ret = -EFAULT;
4524 	}
4525 
4526 out_bargs:
4527 	kfree(bargs);
4528 out_unlock:
4529 	mutex_unlock(&fs_info->balance_mutex);
4530 	mutex_unlock(&fs_info->volume_mutex);
4531 	if (need_unlock)
4532 		atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
4533 out:
4534 	mnt_drop_write_file(file);
4535 	return ret;
4536 }
4537 
4538 static long btrfs_ioctl_balance_ctl(struct btrfs_root *root, int cmd)
4539 {
4540 	if (!capable(CAP_SYS_ADMIN))
4541 		return -EPERM;
4542 
4543 	switch (cmd) {
4544 	case BTRFS_BALANCE_CTL_PAUSE:
4545 		return btrfs_pause_balance(root->fs_info);
4546 	case BTRFS_BALANCE_CTL_CANCEL:
4547 		return btrfs_cancel_balance(root->fs_info);
4548 	}
4549 
4550 	return -EINVAL;
4551 }
4552 
4553 static long btrfs_ioctl_balance_progress(struct btrfs_root *root,
4554 					 void __user *arg)
4555 {
4556 	struct btrfs_fs_info *fs_info = root->fs_info;
4557 	struct btrfs_ioctl_balance_args *bargs;
4558 	int ret = 0;
4559 
4560 	if (!capable(CAP_SYS_ADMIN))
4561 		return -EPERM;
4562 
4563 	mutex_lock(&fs_info->balance_mutex);
4564 	if (!fs_info->balance_ctl) {
4565 		ret = -ENOTCONN;
4566 		goto out;
4567 	}
4568 
4569 	bargs = kzalloc(sizeof(*bargs), GFP_NOFS);
4570 	if (!bargs) {
4571 		ret = -ENOMEM;
4572 		goto out;
4573 	}
4574 
4575 	update_ioctl_balance_args(fs_info, 1, bargs);
4576 
4577 	if (copy_to_user(arg, bargs, sizeof(*bargs)))
4578 		ret = -EFAULT;
4579 
4580 	kfree(bargs);
4581 out:
4582 	mutex_unlock(&fs_info->balance_mutex);
4583 	return ret;
4584 }
4585 
4586 static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
4587 {
4588 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4589 	struct btrfs_ioctl_quota_ctl_args *sa;
4590 	struct btrfs_trans_handle *trans = NULL;
4591 	int ret;
4592 	int err;
4593 
4594 	if (!capable(CAP_SYS_ADMIN))
4595 		return -EPERM;
4596 
4597 	ret = mnt_want_write_file(file);
4598 	if (ret)
4599 		return ret;
4600 
4601 	sa = memdup_user(arg, sizeof(*sa));
4602 	if (IS_ERR(sa)) {
4603 		ret = PTR_ERR(sa);
4604 		goto drop_write;
4605 	}
4606 
4607 	down_write(&root->fs_info->subvol_sem);
4608 	trans = btrfs_start_transaction(root->fs_info->tree_root, 2);
4609 	if (IS_ERR(trans)) {
4610 		ret = PTR_ERR(trans);
4611 		goto out;
4612 	}
4613 
4614 	switch (sa->cmd) {
4615 	case BTRFS_QUOTA_CTL_ENABLE:
4616 		ret = btrfs_quota_enable(trans, root->fs_info);
4617 		break;
4618 	case BTRFS_QUOTA_CTL_DISABLE:
4619 		ret = btrfs_quota_disable(trans, root->fs_info);
4620 		break;
4621 	default:
4622 		ret = -EINVAL;
4623 		break;
4624 	}
4625 
4626 	err = btrfs_commit_transaction(trans, root->fs_info->tree_root);
4627 	if (err && !ret)
4628 		ret = err;
4629 out:
4630 	kfree(sa);
4631 	up_write(&root->fs_info->subvol_sem);
4632 drop_write:
4633 	mnt_drop_write_file(file);
4634 	return ret;
4635 }
4636 
4637 static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
4638 {
4639 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4640 	struct btrfs_ioctl_qgroup_assign_args *sa;
4641 	struct btrfs_trans_handle *trans;
4642 	int ret;
4643 	int err;
4644 
4645 	if (!capable(CAP_SYS_ADMIN))
4646 		return -EPERM;
4647 
4648 	ret = mnt_want_write_file(file);
4649 	if (ret)
4650 		return ret;
4651 
4652 	sa = memdup_user(arg, sizeof(*sa));
4653 	if (IS_ERR(sa)) {
4654 		ret = PTR_ERR(sa);
4655 		goto drop_write;
4656 	}
4657 
4658 	trans = btrfs_join_transaction(root);
4659 	if (IS_ERR(trans)) {
4660 		ret = PTR_ERR(trans);
4661 		goto out;
4662 	}
4663 
4664 	/* FIXME: check if the IDs really exist */
4665 	if (sa->assign) {
4666 		ret = btrfs_add_qgroup_relation(trans, root->fs_info,
4667 						sa->src, sa->dst);
4668 	} else {
4669 		ret = btrfs_del_qgroup_relation(trans, root->fs_info,
4670 						sa->src, sa->dst);
4671 	}
4672 
4673 	err = btrfs_end_transaction(trans, root);
4674 	if (err && !ret)
4675 		ret = err;
4676 
4677 out:
4678 	kfree(sa);
4679 drop_write:
4680 	mnt_drop_write_file(file);
4681 	return ret;
4682 }
4683 
4684 static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
4685 {
4686 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4687 	struct btrfs_ioctl_qgroup_create_args *sa;
4688 	struct btrfs_trans_handle *trans;
4689 	int ret;
4690 	int err;
4691 
4692 	if (!capable(CAP_SYS_ADMIN))
4693 		return -EPERM;
4694 
4695 	ret = mnt_want_write_file(file);
4696 	if (ret)
4697 		return ret;
4698 
4699 	sa = memdup_user(arg, sizeof(*sa));
4700 	if (IS_ERR(sa)) {
4701 		ret = PTR_ERR(sa);
4702 		goto drop_write;
4703 	}
4704 
4705 	if (!sa->qgroupid) {
4706 		ret = -EINVAL;
4707 		goto out;
4708 	}
4709 
4710 	trans = btrfs_join_transaction(root);
4711 	if (IS_ERR(trans)) {
4712 		ret = PTR_ERR(trans);
4713 		goto out;
4714 	}
4715 
4716 	/* FIXME: check if the IDs really exist */
4717 	if (sa->create) {
4718 		ret = btrfs_create_qgroup(trans, root->fs_info, sa->qgroupid,
4719 					  NULL);
4720 	} else {
4721 		ret = btrfs_remove_qgroup(trans, root->fs_info, sa->qgroupid);
4722 	}
4723 
4724 	err = btrfs_end_transaction(trans, root);
4725 	if (err && !ret)
4726 		ret = err;
4727 
4728 out:
4729 	kfree(sa);
4730 drop_write:
4731 	mnt_drop_write_file(file);
4732 	return ret;
4733 }
4734 
4735 static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
4736 {
4737 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4738 	struct btrfs_ioctl_qgroup_limit_args *sa;
4739 	struct btrfs_trans_handle *trans;
4740 	int ret;
4741 	int err;
4742 	u64 qgroupid;
4743 
4744 	if (!capable(CAP_SYS_ADMIN))
4745 		return -EPERM;
4746 
4747 	ret = mnt_want_write_file(file);
4748 	if (ret)
4749 		return ret;
4750 
4751 	sa = memdup_user(arg, sizeof(*sa));
4752 	if (IS_ERR(sa)) {
4753 		ret = PTR_ERR(sa);
4754 		goto drop_write;
4755 	}
4756 
4757 	trans = btrfs_join_transaction(root);
4758 	if (IS_ERR(trans)) {
4759 		ret = PTR_ERR(trans);
4760 		goto out;
4761 	}
4762 
4763 	qgroupid = sa->qgroupid;
4764 	if (!qgroupid) {
4765 		/* take the current subvol as qgroup */
4766 		qgroupid = root->root_key.objectid;
4767 	}
4768 
4769 	/* FIXME: check if the IDs really exist */
4770 	ret = btrfs_limit_qgroup(trans, root->fs_info, qgroupid, &sa->lim);
4771 
4772 	err = btrfs_end_transaction(trans, root);
4773 	if (err && !ret)
4774 		ret = err;
4775 
4776 out:
4777 	kfree(sa);
4778 drop_write:
4779 	mnt_drop_write_file(file);
4780 	return ret;
4781 }
4782 
4783 static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg)
4784 {
4785 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4786 	struct btrfs_ioctl_quota_rescan_args *qsa;
4787 	int ret;
4788 
4789 	if (!capable(CAP_SYS_ADMIN))
4790 		return -EPERM;
4791 
4792 	ret = mnt_want_write_file(file);
4793 	if (ret)
4794 		return ret;
4795 
4796 	qsa = memdup_user(arg, sizeof(*qsa));
4797 	if (IS_ERR(qsa)) {
4798 		ret = PTR_ERR(qsa);
4799 		goto drop_write;
4800 	}
4801 
4802 	if (qsa->flags) {
4803 		ret = -EINVAL;
4804 		goto out;
4805 	}
4806 
4807 	ret = btrfs_qgroup_rescan(root->fs_info);
4808 
4809 out:
4810 	kfree(qsa);
4811 drop_write:
4812 	mnt_drop_write_file(file);
4813 	return ret;
4814 }
4815 
4816 static long btrfs_ioctl_quota_rescan_status(struct file *file, void __user *arg)
4817 {
4818 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4819 	struct btrfs_ioctl_quota_rescan_args *qsa;
4820 	int ret = 0;
4821 
4822 	if (!capable(CAP_SYS_ADMIN))
4823 		return -EPERM;
4824 
4825 	qsa = kzalloc(sizeof(*qsa), GFP_NOFS);
4826 	if (!qsa)
4827 		return -ENOMEM;
4828 
4829 	if (root->fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
4830 		qsa->flags = 1;
4831 		qsa->progress = root->fs_info->qgroup_rescan_progress.objectid;
4832 	}
4833 
4834 	if (copy_to_user(arg, qsa, sizeof(*qsa)))
4835 		ret = -EFAULT;
4836 
4837 	kfree(qsa);
4838 	return ret;
4839 }
4840 
4841 static long btrfs_ioctl_quota_rescan_wait(struct file *file, void __user *arg)
4842 {
4843 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
4844 
4845 	if (!capable(CAP_SYS_ADMIN))
4846 		return -EPERM;
4847 
4848 	return btrfs_qgroup_wait_for_completion(root->fs_info);
4849 }
4850 
4851 static long _btrfs_ioctl_set_received_subvol(struct file *file,
4852 					    struct btrfs_ioctl_received_subvol_args *sa)
4853 {
4854 	struct inode *inode = file_inode(file);
4855 	struct btrfs_root *root = BTRFS_I(inode)->root;
4856 	struct btrfs_root_item *root_item = &root->root_item;
4857 	struct btrfs_trans_handle *trans;
4858 	struct timespec ct = CURRENT_TIME;
4859 	int ret = 0;
4860 	int received_uuid_changed;
4861 
4862 	if (!inode_owner_or_capable(inode))
4863 		return -EPERM;
4864 
4865 	ret = mnt_want_write_file(file);
4866 	if (ret < 0)
4867 		return ret;
4868 
4869 	down_write(&root->fs_info->subvol_sem);
4870 
4871 	if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
4872 		ret = -EINVAL;
4873 		goto out;
4874 	}
4875 
4876 	if (btrfs_root_readonly(root)) {
4877 		ret = -EROFS;
4878 		goto out;
4879 	}
4880 
4881 	/*
4882 	 * 1 - root item
4883 	 * 2 - uuid items (received uuid + subvol uuid)
4884 	 */
4885 	trans = btrfs_start_transaction(root, 3);
4886 	if (IS_ERR(trans)) {
4887 		ret = PTR_ERR(trans);
4888 		trans = NULL;
4889 		goto out;
4890 	}
4891 
4892 	sa->rtransid = trans->transid;
4893 	sa->rtime.sec = ct.tv_sec;
4894 	sa->rtime.nsec = ct.tv_nsec;
4895 
4896 	received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid,
4897 				       BTRFS_UUID_SIZE);
4898 	if (received_uuid_changed &&
4899 	    !btrfs_is_empty_uuid(root_item->received_uuid))
4900 		btrfs_uuid_tree_rem(trans, root->fs_info->uuid_root,
4901 				    root_item->received_uuid,
4902 				    BTRFS_UUID_KEY_RECEIVED_SUBVOL,
4903 				    root->root_key.objectid);
4904 	memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
4905 	btrfs_set_root_stransid(root_item, sa->stransid);
4906 	btrfs_set_root_rtransid(root_item, sa->rtransid);
4907 	btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec);
4908 	btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec);
4909 	btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec);
4910 	btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec);
4911 
4912 	ret = btrfs_update_root(trans, root->fs_info->tree_root,
4913 				&root->root_key, &root->root_item);
4914 	if (ret < 0) {
4915 		btrfs_end_transaction(trans, root);
4916 		goto out;
4917 	}
4918 	if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
4919 		ret = btrfs_uuid_tree_add(trans, root->fs_info->uuid_root,
4920 					  sa->uuid,
4921 					  BTRFS_UUID_KEY_RECEIVED_SUBVOL,
4922 					  root->root_key.objectid);
4923 		if (ret < 0 && ret != -EEXIST) {
4924 			btrfs_abort_transaction(trans, root, ret);
4925 			goto out;
4926 		}
4927 	}
4928 	ret = btrfs_commit_transaction(trans, root);
4929 	if (ret < 0) {
4930 		btrfs_abort_transaction(trans, root, ret);
4931 		goto out;
4932 	}
4933 
4934 out:
4935 	up_write(&root->fs_info->subvol_sem);
4936 	mnt_drop_write_file(file);
4937 	return ret;
4938 }
4939 
4940 #ifdef CONFIG_64BIT
4941 static long btrfs_ioctl_set_received_subvol_32(struct file *file,
4942 						void __user *arg)
4943 {
4944 	struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL;
4945 	struct btrfs_ioctl_received_subvol_args *args64 = NULL;
4946 	int ret = 0;
4947 
4948 	args32 = memdup_user(arg, sizeof(*args32));
4949 	if (IS_ERR(args32)) {
4950 		ret = PTR_ERR(args32);
4951 		args32 = NULL;
4952 		goto out;
4953 	}
4954 
4955 	args64 = kmalloc(sizeof(*args64), GFP_NOFS);
4956 	if (!args64) {
4957 		ret = -ENOMEM;
4958 		goto out;
4959 	}
4960 
4961 	memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE);
4962 	args64->stransid = args32->stransid;
4963 	args64->rtransid = args32->rtransid;
4964 	args64->stime.sec = args32->stime.sec;
4965 	args64->stime.nsec = args32->stime.nsec;
4966 	args64->rtime.sec = args32->rtime.sec;
4967 	args64->rtime.nsec = args32->rtime.nsec;
4968 	args64->flags = args32->flags;
4969 
4970 	ret = _btrfs_ioctl_set_received_subvol(file, args64);
4971 	if (ret)
4972 		goto out;
4973 
4974 	memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE);
4975 	args32->stransid = args64->stransid;
4976 	args32->rtransid = args64->rtransid;
4977 	args32->stime.sec = args64->stime.sec;
4978 	args32->stime.nsec = args64->stime.nsec;
4979 	args32->rtime.sec = args64->rtime.sec;
4980 	args32->rtime.nsec = args64->rtime.nsec;
4981 	args32->flags = args64->flags;
4982 
4983 	ret = copy_to_user(arg, args32, sizeof(*args32));
4984 	if (ret)
4985 		ret = -EFAULT;
4986 
4987 out:
4988 	kfree(args32);
4989 	kfree(args64);
4990 	return ret;
4991 }
4992 #endif
4993 
4994 static long btrfs_ioctl_set_received_subvol(struct file *file,
4995 					    void __user *arg)
4996 {
4997 	struct btrfs_ioctl_received_subvol_args *sa = NULL;
4998 	int ret = 0;
4999 
5000 	sa = memdup_user(arg, sizeof(*sa));
5001 	if (IS_ERR(sa)) {
5002 		ret = PTR_ERR(sa);
5003 		sa = NULL;
5004 		goto out;
5005 	}
5006 
5007 	ret = _btrfs_ioctl_set_received_subvol(file, sa);
5008 
5009 	if (ret)
5010 		goto out;
5011 
5012 	ret = copy_to_user(arg, sa, sizeof(*sa));
5013 	if (ret)
5014 		ret = -EFAULT;
5015 
5016 out:
5017 	kfree(sa);
5018 	return ret;
5019 }
5020 
5021 static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg)
5022 {
5023 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
5024 	size_t len;
5025 	int ret;
5026 	char label[BTRFS_LABEL_SIZE];
5027 
5028 	spin_lock(&root->fs_info->super_lock);
5029 	memcpy(label, root->fs_info->super_copy->label, BTRFS_LABEL_SIZE);
5030 	spin_unlock(&root->fs_info->super_lock);
5031 
5032 	len = strnlen(label, BTRFS_LABEL_SIZE);
5033 
5034 	if (len == BTRFS_LABEL_SIZE) {
5035 		btrfs_warn(root->fs_info,
5036 			"label is too long, return the first %zu bytes", --len);
5037 	}
5038 
5039 	ret = copy_to_user(arg, label, len);
5040 
5041 	return ret ? -EFAULT : 0;
5042 }
5043 
5044 static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
5045 {
5046 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
5047 	struct btrfs_super_block *super_block = root->fs_info->super_copy;
5048 	struct btrfs_trans_handle *trans;
5049 	char label[BTRFS_LABEL_SIZE];
5050 	int ret;
5051 
5052 	if (!capable(CAP_SYS_ADMIN))
5053 		return -EPERM;
5054 
5055 	if (copy_from_user(label, arg, sizeof(label)))
5056 		return -EFAULT;
5057 
5058 	if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
5059 		btrfs_err(root->fs_info, "unable to set label with more than %d bytes",
5060 		       BTRFS_LABEL_SIZE - 1);
5061 		return -EINVAL;
5062 	}
5063 
5064 	ret = mnt_want_write_file(file);
5065 	if (ret)
5066 		return ret;
5067 
5068 	trans = btrfs_start_transaction(root, 0);
5069 	if (IS_ERR(trans)) {
5070 		ret = PTR_ERR(trans);
5071 		goto out_unlock;
5072 	}
5073 
5074 	spin_lock(&root->fs_info->super_lock);
5075 	strcpy(super_block->label, label);
5076 	spin_unlock(&root->fs_info->super_lock);
5077 	ret = btrfs_commit_transaction(trans, root);
5078 
5079 out_unlock:
5080 	mnt_drop_write_file(file);
5081 	return ret;
5082 }
5083 
5084 #define INIT_FEATURE_FLAGS(suffix) \
5085 	{ .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \
5086 	  .compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \
5087 	  .incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix }
5088 
5089 static int btrfs_ioctl_get_supported_features(struct file *file,
5090 					      void __user *arg)
5091 {
5092 	static struct btrfs_ioctl_feature_flags features[3] = {
5093 		INIT_FEATURE_FLAGS(SUPP),
5094 		INIT_FEATURE_FLAGS(SAFE_SET),
5095 		INIT_FEATURE_FLAGS(SAFE_CLEAR)
5096 	};
5097 
5098 	if (copy_to_user(arg, &features, sizeof(features)))
5099 		return -EFAULT;
5100 
5101 	return 0;
5102 }
5103 
5104 static int btrfs_ioctl_get_features(struct file *file, void __user *arg)
5105 {
5106 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
5107 	struct btrfs_super_block *super_block = root->fs_info->super_copy;
5108 	struct btrfs_ioctl_feature_flags features;
5109 
5110 	features.compat_flags = btrfs_super_compat_flags(super_block);
5111 	features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block);
5112 	features.incompat_flags = btrfs_super_incompat_flags(super_block);
5113 
5114 	if (copy_to_user(arg, &features, sizeof(features)))
5115 		return -EFAULT;
5116 
5117 	return 0;
5118 }
5119 
5120 static int check_feature_bits(struct btrfs_root *root,
5121 			      enum btrfs_feature_set set,
5122 			      u64 change_mask, u64 flags, u64 supported_flags,
5123 			      u64 safe_set, u64 safe_clear)
5124 {
5125 	const char *type = btrfs_feature_set_names[set];
5126 	char *names;
5127 	u64 disallowed, unsupported;
5128 	u64 set_mask = flags & change_mask;
5129 	u64 clear_mask = ~flags & change_mask;
5130 
5131 	unsupported = set_mask & ~supported_flags;
5132 	if (unsupported) {
5133 		names = btrfs_printable_features(set, unsupported);
5134 		if (names) {
5135 			btrfs_warn(root->fs_info,
5136 			   "this kernel does not support the %s feature bit%s",
5137 			   names, strchr(names, ',') ? "s" : "");
5138 			kfree(names);
5139 		} else
5140 			btrfs_warn(root->fs_info,
5141 			   "this kernel does not support %s bits 0x%llx",
5142 			   type, unsupported);
5143 		return -EOPNOTSUPP;
5144 	}
5145 
5146 	disallowed = set_mask & ~safe_set;
5147 	if (disallowed) {
5148 		names = btrfs_printable_features(set, disallowed);
5149 		if (names) {
5150 			btrfs_warn(root->fs_info,
5151 			   "can't set the %s feature bit%s while mounted",
5152 			   names, strchr(names, ',') ? "s" : "");
5153 			kfree(names);
5154 		} else
5155 			btrfs_warn(root->fs_info,
5156 			   "can't set %s bits 0x%llx while mounted",
5157 			   type, disallowed);
5158 		return -EPERM;
5159 	}
5160 
5161 	disallowed = clear_mask & ~safe_clear;
5162 	if (disallowed) {
5163 		names = btrfs_printable_features(set, disallowed);
5164 		if (names) {
5165 			btrfs_warn(root->fs_info,
5166 			   "can't clear the %s feature bit%s while mounted",
5167 			   names, strchr(names, ',') ? "s" : "");
5168 			kfree(names);
5169 		} else
5170 			btrfs_warn(root->fs_info,
5171 			   "can't clear %s bits 0x%llx while mounted",
5172 			   type, disallowed);
5173 		return -EPERM;
5174 	}
5175 
5176 	return 0;
5177 }
5178 
5179 #define check_feature(root, change_mask, flags, mask_base)	\
5180 check_feature_bits(root, FEAT_##mask_base, change_mask, flags,	\
5181 		   BTRFS_FEATURE_ ## mask_base ## _SUPP,	\
5182 		   BTRFS_FEATURE_ ## mask_base ## _SAFE_SET,	\
5183 		   BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR)
5184 
5185 static int btrfs_ioctl_set_features(struct file *file, void __user *arg)
5186 {
5187 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
5188 	struct btrfs_super_block *super_block = root->fs_info->super_copy;
5189 	struct btrfs_ioctl_feature_flags flags[2];
5190 	struct btrfs_trans_handle *trans;
5191 	u64 newflags;
5192 	int ret;
5193 
5194 	if (!capable(CAP_SYS_ADMIN))
5195 		return -EPERM;
5196 
5197 	if (copy_from_user(flags, arg, sizeof(flags)))
5198 		return -EFAULT;
5199 
5200 	/* Nothing to do */
5201 	if (!flags[0].compat_flags && !flags[0].compat_ro_flags &&
5202 	    !flags[0].incompat_flags)
5203 		return 0;
5204 
5205 	ret = check_feature(root, flags[0].compat_flags,
5206 			    flags[1].compat_flags, COMPAT);
5207 	if (ret)
5208 		return ret;
5209 
5210 	ret = check_feature(root, flags[0].compat_ro_flags,
5211 			    flags[1].compat_ro_flags, COMPAT_RO);
5212 	if (ret)
5213 		return ret;
5214 
5215 	ret = check_feature(root, flags[0].incompat_flags,
5216 			    flags[1].incompat_flags, INCOMPAT);
5217 	if (ret)
5218 		return ret;
5219 
5220 	trans = btrfs_start_transaction(root, 0);
5221 	if (IS_ERR(trans))
5222 		return PTR_ERR(trans);
5223 
5224 	spin_lock(&root->fs_info->super_lock);
5225 	newflags = btrfs_super_compat_flags(super_block);
5226 	newflags |= flags[0].compat_flags & flags[1].compat_flags;
5227 	newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags);
5228 	btrfs_set_super_compat_flags(super_block, newflags);
5229 
5230 	newflags = btrfs_super_compat_ro_flags(super_block);
5231 	newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags;
5232 	newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags);
5233 	btrfs_set_super_compat_ro_flags(super_block, newflags);
5234 
5235 	newflags = btrfs_super_incompat_flags(super_block);
5236 	newflags |= flags[0].incompat_flags & flags[1].incompat_flags;
5237 	newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags);
5238 	btrfs_set_super_incompat_flags(super_block, newflags);
5239 	spin_unlock(&root->fs_info->super_lock);
5240 
5241 	return btrfs_commit_transaction(trans, root);
5242 }
5243 
5244 long btrfs_ioctl(struct file *file, unsigned int
5245 		cmd, unsigned long arg)
5246 {
5247 	struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
5248 	void __user *argp = (void __user *)arg;
5249 
5250 	switch (cmd) {
5251 	case FS_IOC_GETFLAGS:
5252 		return btrfs_ioctl_getflags(file, argp);
5253 	case FS_IOC_SETFLAGS:
5254 		return btrfs_ioctl_setflags(file, argp);
5255 	case FS_IOC_GETVERSION:
5256 		return btrfs_ioctl_getversion(file, argp);
5257 	case FITRIM:
5258 		return btrfs_ioctl_fitrim(file, argp);
5259 	case BTRFS_IOC_SNAP_CREATE:
5260 		return btrfs_ioctl_snap_create(file, argp, 0);
5261 	case BTRFS_IOC_SNAP_CREATE_V2:
5262 		return btrfs_ioctl_snap_create_v2(file, argp, 0);
5263 	case BTRFS_IOC_SUBVOL_CREATE:
5264 		return btrfs_ioctl_snap_create(file, argp, 1);
5265 	case BTRFS_IOC_SUBVOL_CREATE_V2:
5266 		return btrfs_ioctl_snap_create_v2(file, argp, 1);
5267 	case BTRFS_IOC_SNAP_DESTROY:
5268 		return btrfs_ioctl_snap_destroy(file, argp);
5269 	case BTRFS_IOC_SUBVOL_GETFLAGS:
5270 		return btrfs_ioctl_subvol_getflags(file, argp);
5271 	case BTRFS_IOC_SUBVOL_SETFLAGS:
5272 		return btrfs_ioctl_subvol_setflags(file, argp);
5273 	case BTRFS_IOC_DEFAULT_SUBVOL:
5274 		return btrfs_ioctl_default_subvol(file, argp);
5275 	case BTRFS_IOC_DEFRAG:
5276 		return btrfs_ioctl_defrag(file, NULL);
5277 	case BTRFS_IOC_DEFRAG_RANGE:
5278 		return btrfs_ioctl_defrag(file, argp);
5279 	case BTRFS_IOC_RESIZE:
5280 		return btrfs_ioctl_resize(file, argp);
5281 	case BTRFS_IOC_ADD_DEV:
5282 		return btrfs_ioctl_add_dev(root, argp);
5283 	case BTRFS_IOC_RM_DEV:
5284 		return btrfs_ioctl_rm_dev(file, argp);
5285 	case BTRFS_IOC_FS_INFO:
5286 		return btrfs_ioctl_fs_info(root, argp);
5287 	case BTRFS_IOC_DEV_INFO:
5288 		return btrfs_ioctl_dev_info(root, argp);
5289 	case BTRFS_IOC_BALANCE:
5290 		return btrfs_ioctl_balance(file, NULL);
5291 	case BTRFS_IOC_CLONE:
5292 		return btrfs_ioctl_clone(file, arg, 0, 0, 0);
5293 	case BTRFS_IOC_CLONE_RANGE:
5294 		return btrfs_ioctl_clone_range(file, argp);
5295 	case BTRFS_IOC_TRANS_START:
5296 		return btrfs_ioctl_trans_start(file);
5297 	case BTRFS_IOC_TRANS_END:
5298 		return btrfs_ioctl_trans_end(file);
5299 	case BTRFS_IOC_TREE_SEARCH:
5300 		return btrfs_ioctl_tree_search(file, argp);
5301 	case BTRFS_IOC_TREE_SEARCH_V2:
5302 		return btrfs_ioctl_tree_search_v2(file, argp);
5303 	case BTRFS_IOC_INO_LOOKUP:
5304 		return btrfs_ioctl_ino_lookup(file, argp);
5305 	case BTRFS_IOC_INO_PATHS:
5306 		return btrfs_ioctl_ino_to_path(root, argp);
5307 	case BTRFS_IOC_LOGICAL_INO:
5308 		return btrfs_ioctl_logical_to_ino(root, argp);
5309 	case BTRFS_IOC_SPACE_INFO:
5310 		return btrfs_ioctl_space_info(root, argp);
5311 	case BTRFS_IOC_SYNC: {
5312 		int ret;
5313 
5314 		ret = btrfs_start_delalloc_roots(root->fs_info, 0, -1);
5315 		if (ret)
5316 			return ret;
5317 		ret = btrfs_sync_fs(file->f_dentry->d_sb, 1);
5318 		/*
5319 		 * The transaction thread may want to do more work,
5320 		 * namely it pokes the cleaner ktread that will start
5321 		 * processing uncleaned subvols.
5322 		 */
5323 		wake_up_process(root->fs_info->transaction_kthread);
5324 		return ret;
5325 	}
5326 	case BTRFS_IOC_START_SYNC:
5327 		return btrfs_ioctl_start_sync(root, argp);
5328 	case BTRFS_IOC_WAIT_SYNC:
5329 		return btrfs_ioctl_wait_sync(root, argp);
5330 	case BTRFS_IOC_SCRUB:
5331 		return btrfs_ioctl_scrub(file, argp);
5332 	case BTRFS_IOC_SCRUB_CANCEL:
5333 		return btrfs_ioctl_scrub_cancel(root, argp);
5334 	case BTRFS_IOC_SCRUB_PROGRESS:
5335 		return btrfs_ioctl_scrub_progress(root, argp);
5336 	case BTRFS_IOC_BALANCE_V2:
5337 		return btrfs_ioctl_balance(file, argp);
5338 	case BTRFS_IOC_BALANCE_CTL:
5339 		return btrfs_ioctl_balance_ctl(root, arg);
5340 	case BTRFS_IOC_BALANCE_PROGRESS:
5341 		return btrfs_ioctl_balance_progress(root, argp);
5342 	case BTRFS_IOC_SET_RECEIVED_SUBVOL:
5343 		return btrfs_ioctl_set_received_subvol(file, argp);
5344 #ifdef CONFIG_64BIT
5345 	case BTRFS_IOC_SET_RECEIVED_SUBVOL_32:
5346 		return btrfs_ioctl_set_received_subvol_32(file, argp);
5347 #endif
5348 	case BTRFS_IOC_SEND:
5349 		return btrfs_ioctl_send(file, argp);
5350 	case BTRFS_IOC_GET_DEV_STATS:
5351 		return btrfs_ioctl_get_dev_stats(root, argp);
5352 	case BTRFS_IOC_QUOTA_CTL:
5353 		return btrfs_ioctl_quota_ctl(file, argp);
5354 	case BTRFS_IOC_QGROUP_ASSIGN:
5355 		return btrfs_ioctl_qgroup_assign(file, argp);
5356 	case BTRFS_IOC_QGROUP_CREATE:
5357 		return btrfs_ioctl_qgroup_create(file, argp);
5358 	case BTRFS_IOC_QGROUP_LIMIT:
5359 		return btrfs_ioctl_qgroup_limit(file, argp);
5360 	case BTRFS_IOC_QUOTA_RESCAN:
5361 		return btrfs_ioctl_quota_rescan(file, argp);
5362 	case BTRFS_IOC_QUOTA_RESCAN_STATUS:
5363 		return btrfs_ioctl_quota_rescan_status(file, argp);
5364 	case BTRFS_IOC_QUOTA_RESCAN_WAIT:
5365 		return btrfs_ioctl_quota_rescan_wait(file, argp);
5366 	case BTRFS_IOC_DEV_REPLACE:
5367 		return btrfs_ioctl_dev_replace(root, argp);
5368 	case BTRFS_IOC_GET_FSLABEL:
5369 		return btrfs_ioctl_get_fslabel(file, argp);
5370 	case BTRFS_IOC_SET_FSLABEL:
5371 		return btrfs_ioctl_set_fslabel(file, argp);
5372 	case BTRFS_IOC_FILE_EXTENT_SAME:
5373 		return btrfs_ioctl_file_extent_same(file, argp);
5374 	case BTRFS_IOC_GET_SUPPORTED_FEATURES:
5375 		return btrfs_ioctl_get_supported_features(file, argp);
5376 	case BTRFS_IOC_GET_FEATURES:
5377 		return btrfs_ioctl_get_features(file, argp);
5378 	case BTRFS_IOC_SET_FEATURES:
5379 		return btrfs_ioctl_set_features(file, argp);
5380 	}
5381 
5382 	return -ENOTTY;
5383 }
5384