projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Btrfs: fix wrong handle at error path of create_snapshot() when the commit fails
[deliverable/linux.git] / fs / btrfs / ioctl.c
CommitLineData
f46b5a66
CH		 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>
cb8e7090 24#include <linux/fsnotify.h>
f46b5a66
CH		 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>
f46b5a66 30#include <linux/backing-dev.h>
cb8e7090 31#include <linux/mount.h>
f46b5a66 32#include <linux/mpage.h>
cb8e7090 33#include <linux/namei.h>
f46b5a66
CH		 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>
cb8e7090 39#include <linux/security.h>
f46b5a66 40#include <linux/xattr.h>
7ea394f1 41#include <linux/vmalloc.h>
5a0e3ad6 42#include <linux/slab.h>
f7039b1d 43#include <linux/blkdev.h>
8ea05e3a 44#include <linux/uuid.h>
55e301fd 45#include <linux/btrfs.h>
4b4e25f2 46#include "compat.h"
f46b5a66
CH		 47#include "ctree.h"
48#include "disk-io.h"
49#include "transaction.h"
50#include "btrfs_inode.h"
f46b5a66
CH		 51#include "print-tree.h"
52#include "volumes.h"
925baedd 53#include "locking.h"
581bb050 54#include "inode-map.h"
d7728c96 55#include "backref.h"
606686ee 56#include "rcu-string.h"
31db9f7c 57#include "send.h"
3f6bcfbd 58#include "dev-replace.h"
f46b5a66 59
6cbff00f
CH		 60/* Mask out flags that are inappropriate for the given type of inode. */
61static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
62{
63 if (S_ISDIR(mode))
64 return flags;
65 else if (S_ISREG(mode))
66 return flags & ~FS_DIRSYNC_FL;
67 else
68 return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
69}
70
71/*
72 * Export inode flags to the format expected by the FS_IOC_GETFLAGS ioctl.
73 */
74static unsigned int btrfs_flags_to_ioctl(unsigned int flags)
75{
76 unsigned int iflags = 0;
77
78 if (flags & BTRFS_INODE_SYNC)
79 iflags |= FS_SYNC_FL;
80 if (flags & BTRFS_INODE_IMMUTABLE)
81 iflags |= FS_IMMUTABLE_FL;
82 if (flags & BTRFS_INODE_APPEND)
83 iflags |= FS_APPEND_FL;
84 if (flags & BTRFS_INODE_NODUMP)
85 iflags |= FS_NODUMP_FL;
86 if (flags & BTRFS_INODE_NOATIME)
87 iflags |= FS_NOATIME_FL;
88 if (flags & BTRFS_INODE_DIRSYNC)
89 iflags |= FS_DIRSYNC_FL;
d0092bdd
LZ		 90 if (flags & BTRFS_INODE_NODATACOW)
91 iflags |= FS_NOCOW_FL;
92
93 if ((flags & BTRFS_INODE_COMPRESS) && !(flags & BTRFS_INODE_NOCOMPRESS))
94 iflags |= FS_COMPR_FL;
95 else if (flags & BTRFS_INODE_NOCOMPRESS)
96 iflags |= FS_NOCOMP_FL;
6cbff00f
CH		 97
98 return iflags;
99}
100
101/*
102 * Update inode->i_flags based on the btrfs internal flags.
103 */
104void btrfs_update_iflags(struct inode *inode)
105{
106 struct btrfs_inode *ip = BTRFS_I(inode);
107
108 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
109
110 if (ip->flags & BTRFS_INODE_SYNC)
111 inode->i_flags |= S_SYNC;
112 if (ip->flags & BTRFS_INODE_IMMUTABLE)
113 inode->i_flags |= S_IMMUTABLE;
114 if (ip->flags & BTRFS_INODE_APPEND)
115 inode->i_flags |= S_APPEND;
116 if (ip->flags & BTRFS_INODE_NOATIME)
117 inode->i_flags |= S_NOATIME;
118 if (ip->flags & BTRFS_INODE_DIRSYNC)
119 inode->i_flags |= S_DIRSYNC;
120}
121
122/*
123 * Inherit flags from the parent inode.
124 *
e27425d6 125 * Currently only the compression flags and the cow flags are inherited.
6cbff00f
CH		 126 */
127void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
128{
0b4dcea5
CM		 129 unsigned int flags;
130
131 if (!dir)
132 return;
133
134 flags = BTRFS_I(dir)->flags;
6cbff00f 135
e27425d6
JB		 136 if (flags & BTRFS_INODE_NOCOMPRESS) {
137 BTRFS_I(inode)->flags &= ~BTRFS_INODE_COMPRESS;
138 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
139 } else if (flags & BTRFS_INODE_COMPRESS) {
140 BTRFS_I(inode)->flags &= ~BTRFS_INODE_NOCOMPRESS;
141 BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
142 }
143
213490b3 144 if (flags & BTRFS_INODE_NODATACOW) {
e27425d6 145 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
213490b3
LB		 146 if (S_ISREG(inode->i_mode))
147 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
148 }
6cbff00f 149
6cbff00f
CH		 150 btrfs_update_iflags(inode);
151}
152
153static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
154{
155 struct btrfs_inode *ip = BTRFS_I(file->f_path.dentry->d_inode);
156 unsigned int flags = btrfs_flags_to_ioctl(ip->flags);
157
158 if (copy_to_user(arg, &flags, sizeof(flags)))
159 return -EFAULT;
160 return 0;
161}
162
75e7cb7f
LB		 163static int check_flags(unsigned int flags)
164{
165 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
166 FS_NOATIME_FL | FS_NODUMP_FL | \
167 FS_SYNC_FL | FS_DIRSYNC_FL | \
e1e8fb6a
LZ		 168 FS_NOCOMP_FL | FS_COMPR_FL |
169 FS_NOCOW_FL))
75e7cb7f
LB		 170 return -EOPNOTSUPP;
171
172 if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
173 return -EINVAL;
174
75e7cb7f
LB		 175 return 0;
176}
177
6cbff00f
CH		 178static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
179{
180 struct inode *inode = file->f_path.dentry->d_inode;
181 struct btrfs_inode *ip = BTRFS_I(inode);
182 struct btrfs_root *root = ip->root;
183 struct btrfs_trans_handle *trans;
184 unsigned int flags, oldflags;
185 int ret;
f062abf0
LZ		 186 u64 ip_oldflags;
187 unsigned int i_oldflags;
7e97b8da 188 umode_t mode;
6cbff00f 189
b83cc969
LZ		 190 if (btrfs_root_readonly(root))
191 return -EROFS;
192
6cbff00f
CH		 193 if (copy_from_user(&flags, arg, sizeof(flags)))
194 return -EFAULT;
195
75e7cb7f
LB		 196 ret = check_flags(flags);
197 if (ret)
198 return ret;
f46b5a66 199
2e149670 200 if (!inode_owner_or_capable(inode))
6cbff00f
CH		 201 return -EACCES;
202
e7848683
JK		 203 ret = mnt_want_write_file(file);
204 if (ret)
205 return ret;
206
6cbff00f
CH		 207 mutex_lock(&inode->i_mutex);
208
f062abf0
LZ		 209 ip_oldflags = ip->flags;
210 i_oldflags = inode->i_flags;
7e97b8da 211 mode = inode->i_mode;
f062abf0 212
6cbff00f
CH		 213 flags = btrfs_mask_flags(inode->i_mode, flags);
214 oldflags = btrfs_flags_to_ioctl(ip->flags);
215 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
216 if (!capable(CAP_LINUX_IMMUTABLE)) {
217 ret = -EPERM;
218 goto out_unlock;
219 }
220 }
221
6cbff00f
CH		 222 if (flags & FS_SYNC_FL)
223 ip->flags |= BTRFS_INODE_SYNC;
224 else
225 ip->flags &= ~BTRFS_INODE_SYNC;
226 if (flags & FS_IMMUTABLE_FL)
227 ip->flags |= BTRFS_INODE_IMMUTABLE;
228 else
229 ip->flags &= ~BTRFS_INODE_IMMUTABLE;
230 if (flags & FS_APPEND_FL)
231 ip->flags |= BTRFS_INODE_APPEND;
232 else
233 ip->flags &= ~BTRFS_INODE_APPEND;
234 if (flags & FS_NODUMP_FL)
235 ip->flags |= BTRFS_INODE_NODUMP;
236 else
237 ip->flags &= ~BTRFS_INODE_NODUMP;
238 if (flags & FS_NOATIME_FL)
239 ip->flags |= BTRFS_INODE_NOATIME;
240 else
241 ip->flags &= ~BTRFS_INODE_NOATIME;
242 if (flags & FS_DIRSYNC_FL)
243 ip->flags |= BTRFS_INODE_DIRSYNC;
244 else
245 ip->flags &= ~BTRFS_INODE_DIRSYNC;
7e97b8da
DS		 246 if (flags & FS_NOCOW_FL) {
247 if (S_ISREG(mode)) {
248 /*
249 * It's safe to turn csums off here, no extents exist.
250 * Otherwise we want the flag to reflect the real COW
251 * status of the file and will not set it.
252 */
253 if (inode->i_size == 0)
254 ip->flags |= BTRFS_INODE_NODATACOW
255 | BTRFS_INODE_NODATASUM;
256 } else {
257 ip->flags |= BTRFS_INODE_NODATACOW;
258 }
259 } else {
260 /*
261 * Revert back under same assuptions as above
262 */
263 if (S_ISREG(mode)) {
264 if (inode->i_size == 0)
265 ip->flags &= ~(BTRFS_INODE_NODATACOW
266 | BTRFS_INODE_NODATASUM);
267 } else {
268 ip->flags &= ~BTRFS_INODE_NODATACOW;
269 }
270 }
6cbff00f 271
75e7cb7f
LB		 272 /*
273 * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
274 * flag may be changed automatically if compression code won't make
275 * things smaller.
276 */
277 if (flags & FS_NOCOMP_FL) {
278 ip->flags &= ~BTRFS_INODE_COMPRESS;
279 ip->flags |= BTRFS_INODE_NOCOMPRESS;
280 } else if (flags & FS_COMPR_FL) {
281 ip->flags |= BTRFS_INODE_COMPRESS;
282 ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
ebcb904d
LZ		 283 } else {
284 ip->flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
75e7cb7f 285 }
6cbff00f 286
4da6f1a3 287 trans = btrfs_start_transaction(root, 1);
f062abf0
LZ		 288 if (IS_ERR(trans)) {
289 ret = PTR_ERR(trans);
290 goto out_drop;
291 }
6cbff00f 292
306424cc 293 btrfs_update_iflags(inode);
0c4d2d95 294 inode_inc_iversion(inode);
306424cc 295 inode->i_ctime = CURRENT_TIME;
6cbff00f 296 ret = btrfs_update_inode(trans, root, inode);
6cbff00f 297
6cbff00f 298 btrfs_end_transaction(trans, root);
f062abf0
LZ		 299 out_drop:
300 if (ret) {
301 ip->flags = ip_oldflags;
302 inode->i_flags = i_oldflags;
303 }
6cbff00f 304
6cbff00f
CH		 305 out_unlock:
306 mutex_unlock(&inode->i_mutex);
e7848683 307 mnt_drop_write_file(file);
2d4e6f6a 308 return ret;
6cbff00f
CH		 309}
310
311static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
312{
313 struct inode *inode = file->f_path.dentry->d_inode;
314
315 return put_user(inode->i_generation, arg);
316}
f46b5a66 317
f7039b1d
LD		 318static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
319{
815745cf 320 struct btrfs_fs_info *fs_info = btrfs_sb(fdentry(file)->d_sb);
f7039b1d
LD		 321 struct btrfs_device *device;
322 struct request_queue *q;
323 struct fstrim_range range;
324 u64 minlen = ULLONG_MAX;
325 u64 num_devices = 0;
815745cf 326 u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
f7039b1d
LD		 327 int ret;
328
329 if (!capable(CAP_SYS_ADMIN))
330 return -EPERM;
331
1f78160c
XG		 332 rcu_read_lock();
333 list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
334 dev_list) {
f7039b1d
LD		 335 if (!device->bdev)
336 continue;
337 q = bdev_get_queue(device->bdev);
338 if (blk_queue_discard(q)) {
339 num_devices++;
340 minlen = min((u64)q->limits.discard_granularity,
341 minlen);
342 }
343 }
1f78160c 344 rcu_read_unlock();
f4c697e6 345
f7039b1d
LD		 346 if (!num_devices)
347 return -EOPNOTSUPP;
f7039b1d
LD		 348 if (copy_from_user(&range, arg, sizeof(range)))
349 return -EFAULT;
e515c18b
LC		 350 if (range.start > total_bytes ||
351 range.len < fs_info->sb->s_blocksize)
f4c697e6 352 return -EINVAL;
f7039b1d 353
f4c697e6 354 range.len = min(range.len, total_bytes - range.start);
f7039b1d 355 range.minlen = max(range.minlen, minlen);
815745cf 356 ret = btrfs_trim_fs(fs_info->tree_root, &range);
f7039b1d
LD		 357 if (ret < 0)
358 return ret;
359
360 if (copy_to_user(arg, &range, sizeof(range)))
361 return -EFAULT;
362
363 return 0;
364}
365
d5c12070 366static noinline int create_subvol(struct inode *dir,
cb8e7090 367 struct dentry *dentry,
72fd032e 368 char *name, int namelen,
6f72c7e2 369 u64 *async_transid,
8696c533 370 struct btrfs_qgroup_inherit *inherit)
f46b5a66
CH		 371{
372 struct btrfs_trans_handle *trans;
373 struct btrfs_key key;
374 struct btrfs_root_item root_item;
375 struct btrfs_inode_item *inode_item;
376 struct extent_buffer *leaf;
d5c12070 377 struct btrfs_root *root = BTRFS_I(dir)->root;
76dda93c 378 struct btrfs_root *new_root;
d5c12070 379 struct btrfs_block_rsv block_rsv;
8ea05e3a 380 struct timespec cur_time = CURRENT_TIME;
f46b5a66
CH		 381 int ret;
382 int err;
383 u64 objectid;
384 u64 new_dirid = BTRFS_FIRST_FREE_OBJECTID;
3de4586c 385 u64 index = 0;
d5c12070 386 u64 qgroup_reserved;
8ea05e3a 387 uuid_le new_uuid;
f46b5a66 388
581bb050 389 ret = btrfs_find_free_objectid(root->fs_info->tree_root, &objectid);
2fbe8c8a 390 if (ret)
a22285a6 391 return ret;
6a912213 392
d5c12070 393 btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
9ed74f2d 394 /*
d5c12070
MX		 395 * The same as the snapshot creation, please see the comment
396 * of create_snapshot().
9ed74f2d 397 */
d5c12070
MX		 398 ret = btrfs_subvolume_reserve_metadata(root, &block_rsv,
399 7, &qgroup_reserved);
400 if (ret)
401 return ret;
402
403 trans = btrfs_start_transaction(root, 0);
404 if (IS_ERR(trans)) {
405 ret = PTR_ERR(trans);
406 goto out;
407 }
408 trans->block_rsv = &block_rsv;
409 trans->bytes_reserved = block_rsv.size;
f46b5a66 410
8696c533 411 ret = btrfs_qgroup_inherit(trans, root->fs_info, 0, objectid, inherit);
6f72c7e2
AJ		 412 if (ret)
413 goto fail;
414
5d4f98a2 415 leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
5581a51a 416 0, objectid, NULL, 0, 0, 0);
8e8a1e31
JB		 417 if (IS_ERR(leaf)) {
418 ret = PTR_ERR(leaf);
419 goto fail;
420 }
f46b5a66 421
5d4f98a2 422 memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
f46b5a66
CH		 423 btrfs_set_header_bytenr(leaf, leaf->start);
424 btrfs_set_header_generation(leaf, trans->transid);
5d4f98a2 425 btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
f46b5a66
CH		 426 btrfs_set_header_owner(leaf, objectid);
427
428 write_extent_buffer(leaf, root->fs_info->fsid,
429 (unsigned long)btrfs_header_fsid(leaf),
430 BTRFS_FSID_SIZE);
5d4f98a2
YZ		 431 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
432 (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
433 BTRFS_UUID_SIZE);
f46b5a66
CH		 434 btrfs_mark_buffer_dirty(leaf);
435
8ea05e3a
AB		 436 memset(&root_item, 0, sizeof(root_item));
437
f46b5a66 438 inode_item = &root_item.inode;
f46b5a66
CH		 439 inode_item->generation = cpu_to_le64(1);
440 inode_item->size = cpu_to_le64(3);
441 inode_item->nlink = cpu_to_le32(1);
a76a3cd4 442 inode_item->nbytes = cpu_to_le64(root->leafsize);
f46b5a66
CH		 443 inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
444
08fe4db1
LZ		 445 root_item.flags = 0;
446 root_item.byte_limit = 0;
447 inode_item->flags = cpu_to_le64(BTRFS_INODE_ROOT_ITEM_INIT);
448
f46b5a66 449 btrfs_set_root_bytenr(&root_item, leaf->start);
84234f3a 450 btrfs_set_root_generation(&root_item, trans->transid);
f46b5a66
CH		 451 btrfs_set_root_level(&root_item, 0);
452 btrfs_set_root_refs(&root_item, 1);
86b9f2ec 453 btrfs_set_root_used(&root_item, leaf->len);
80ff3856 454 btrfs_set_root_last_snapshot(&root_item, 0);
f46b5a66 455
8ea05e3a
AB		 456 btrfs_set_root_generation_v2(&root_item,
457 btrfs_root_generation(&root_item));
458 uuid_le_gen(&new_uuid);
459 memcpy(root_item.uuid, new_uuid.b, BTRFS_UUID_SIZE);
460 root_item.otime.sec = cpu_to_le64(cur_time.tv_sec);
dadd1105 461 root_item.otime.nsec = cpu_to_le32(cur_time.tv_nsec);
8ea05e3a
AB		 462 root_item.ctime = root_item.otime;
463 btrfs_set_root_ctransid(&root_item, trans->transid);
464 btrfs_set_root_otransid(&root_item, trans->transid);
f46b5a66 465
925baedd 466 btrfs_tree_unlock(leaf);
f46b5a66
CH		 467 free_extent_buffer(leaf);
468 leaf = NULL;
469
470 btrfs_set_root_dirid(&root_item, new_dirid);
471
472 key.objectid = objectid;
5d4f98a2 473 key.offset = 0;
f46b5a66
CH		 474 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
475 ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
476 &root_item);
477 if (ret)
478 goto fail;
479
76dda93c
YZ		 480 key.offset = (u64)-1;
481 new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
79787eaa
JM		 482 if (IS_ERR(new_root)) {
483 btrfs_abort_transaction(trans, root, PTR_ERR(new_root));
484 ret = PTR_ERR(new_root);
485 goto fail;
486 }
76dda93c
YZ		 487
488 btrfs_record_root_in_trans(trans, new_root);
489
d82a6f1d 490 ret = btrfs_create_subvol_root(trans, new_root, new_dirid);
ce598979
MF		 491 if (ret) {
492 /* We potentially lose an unused inode item here */
79787eaa 493 btrfs_abort_transaction(trans, root, ret);
ce598979
MF		 494 goto fail;
495 }
496
f46b5a66
CH		 497 /*
498 * insert the directory item
499 */
3de4586c 500 ret = btrfs_set_inode_index(dir, &index);
79787eaa
JM		 501 if (ret) {
502 btrfs_abort_transaction(trans, root, ret);
503 goto fail;
504 }
3de4586c
CM		 505
506 ret = btrfs_insert_dir_item(trans, root,
16cdcec7 507 name, namelen, dir, &key,
3de4586c 508 BTRFS_FT_DIR, index);
79787eaa
JM		 509 if (ret) {
510 btrfs_abort_transaction(trans, root, ret);
f46b5a66 511 goto fail;
79787eaa 512 }
0660b5af 513
52c26179
YZ		 514 btrfs_i_size_write(dir, dir->i_size + namelen * 2);
515 ret = btrfs_update_inode(trans, root, dir);
516 BUG_ON(ret);
517
0660b5af 518 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
4df27c4d 519 objectid, root->root_key.objectid,
33345d01 520 btrfs_ino(dir), index, name, namelen);
0660b5af 521
76dda93c 522 BUG_ON(ret);
f46b5a66 523
f46b5a66 524fail:
d5c12070
MX		 525 trans->block_rsv = NULL;
526 trans->bytes_reserved = 0;
72fd032e
SW		 527 if (async_transid) {
528 *async_transid = trans->transid;
529 err = btrfs_commit_transaction_async(trans, root, 1);
530 } else {
531 err = btrfs_commit_transaction(trans, root);
532 }
f46b5a66
CH		 533 if (err && !ret)
534 ret = err;
1a65e24b
CM		 535
536 if (!ret)
537 d_instantiate(dentry, btrfs_lookup_dentry(dir, dentry));
d5c12070
MX		 538out:
539 btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
f46b5a66
CH		 540 return ret;
541}
542
e9662f70
MX		 543static int create_snapshot(struct btrfs_root *root, struct inode *dir,
544 struct dentry *dentry, char *name, int namelen,
545 u64 *async_transid, bool readonly,
546 struct btrfs_qgroup_inherit *inherit)
f46b5a66 547{
2e4bfab9 548 struct inode *inode;
f46b5a66
CH		 549 struct btrfs_pending_snapshot *pending_snapshot;
550 struct btrfs_trans_handle *trans;
2e4bfab9 551 int ret;
f46b5a66
CH		 552
553 if (!root->ref_cows)
554 return -EINVAL;
555
3de4586c 556 pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
a22285a6
YZ		 557 if (!pending_snapshot)
558 return -ENOMEM;
559
66d8f3dd
MX		 560 btrfs_init_block_rsv(&pending_snapshot->block_rsv,
561 BTRFS_BLOCK_RSV_TEMP);
d5c12070
MX		 562 /*
563 * 1 - parent dir inode
564 * 2 - dir entries
565 * 1 - root item
566 * 2 - root ref/backref
567 * 1 - root of snapshot
568 */
569 ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
570 &pending_snapshot->block_rsv, 7,
571 &pending_snapshot->qgroup_reserved);
572 if (ret)
573 goto out;
574
3de4586c 575 pending_snapshot->dentry = dentry;
f46b5a66 576 pending_snapshot->root = root;
b83cc969 577 pending_snapshot->readonly = readonly;
e9662f70 578 pending_snapshot->dir = dir;
8696c533 579 pending_snapshot->inherit = inherit;
a22285a6 580
d5c12070 581 trans = btrfs_start_transaction(root, 0);
a22285a6
YZ		 582 if (IS_ERR(trans)) {
583 ret = PTR_ERR(trans);
584 goto fail;
585 }
586
8351583e 587 spin_lock(&root->fs_info->trans_lock);
f46b5a66
CH		 588 list_add(&pending_snapshot->list,
589 &trans->transaction->pending_snapshots);
8351583e 590 spin_unlock(&root->fs_info->trans_lock);
72fd032e
SW		 591 if (async_transid) {
592 *async_transid = trans->transid;
593 ret = btrfs_commit_transaction_async(trans,
594 root->fs_info->extent_root, 1);
595 } else {
596 ret = btrfs_commit_transaction(trans,
597 root->fs_info->extent_root);
598 }
aec8030a 599 if (ret)
c37b2b62 600 goto fail;
a22285a6
YZ		 601
602 ret = pending_snapshot->error;
603 if (ret)
604 goto fail;
605
66b4ffd1
JB		 606 ret = btrfs_orphan_cleanup(pending_snapshot->snap);
607 if (ret)
608 goto fail;
f46b5a66 609
2fbe8c8a 610 inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
2e4bfab9
YZ		 611 if (IS_ERR(inode)) {
612 ret = PTR_ERR(inode);
613 goto fail;
614 }
615 BUG_ON(!inode);
616 d_instantiate(dentry, inode);
617 ret = 0;
618fail:
d5c12070
MX		 619 btrfs_subvolume_release_metadata(BTRFS_I(dir)->root,
620 &pending_snapshot->block_rsv,
621 pending_snapshot->qgroup_reserved);
622out:
a22285a6 623 kfree(pending_snapshot);
f46b5a66
CH		 624 return ret;
625}
626
4260f7c7
SW		 627/* copy of check_sticky in fs/namei.c()
628* It's inline, so penalty for filesystems that don't use sticky bit is
629* minimal.
630*/
631static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
632{
2f2f43d3 633 kuid_t fsuid = current_fsuid();
4260f7c7
SW		 634
635 if (!(dir->i_mode & S_ISVTX))
636 return 0;
2f2f43d3 637 if (uid_eq(inode->i_uid, fsuid))
4260f7c7 638 return 0;
2f2f43d3 639 if (uid_eq(dir->i_uid, fsuid))
4260f7c7
SW		 640 return 0;
641 return !capable(CAP_FOWNER);
642}
643
644/* copy of may_delete in fs/namei.c()
645 * Check whether we can remove a link victim from directory dir, check
646 * whether the type of victim is right.
647 * 1. We can't do it if dir is read-only (done in permission())
648 * 2. We should have write and exec permissions on dir
649 * 3. We can't remove anything from append-only dir
650 * 4. We can't do anything with immutable dir (done in permission())
651 * 5. If the sticky bit on dir is set we should either
652 * a. be owner of dir, or
653 * b. be owner of victim, or
654 * c. have CAP_FOWNER capability
655 * 6. If the victim is append-only or immutable we can't do antyhing with
656 * links pointing to it.
657 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
658 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
659 * 9. We can't remove a root or mountpoint.
660 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
661 * nfs_async_unlink().
662 */
663
664static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir)
665{
666 int error;
667
668 if (!victim->d_inode)
669 return -ENOENT;
670
671 BUG_ON(victim->d_parent->d_inode != dir);
4fa6b5ec 672 audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
4260f7c7
SW		 673
674 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
675 if (error)
676 return error;
677 if (IS_APPEND(dir))
678 return -EPERM;
679 if (btrfs_check_sticky(dir, victim->d_inode)||
680 IS_APPEND(victim->d_inode)||
681 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
682 return -EPERM;
683 if (isdir) {
684 if (!S_ISDIR(victim->d_inode->i_mode))
685 return -ENOTDIR;
686 if (IS_ROOT(victim))
687 return -EBUSY;
688 } else if (S_ISDIR(victim->d_inode->i_mode))
689 return -EISDIR;
690 if (IS_DEADDIR(dir))
691 return -ENOENT;
692 if (victim->d_flags & DCACHE_NFSFS_RENAMED)
693 return -EBUSY;
694 return 0;
695}
696
cb8e7090
CH		 697/* copy of may_create in fs/namei.c() */
698static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
699{
700 if (child->d_inode)
701 return -EEXIST;
702 if (IS_DEADDIR(dir))
703 return -ENOENT;
704 return inode_permission(dir, MAY_WRITE | MAY_EXEC);
705}
706
707/*
708 * Create a new subvolume below @parent. This is largely modeled after
709 * sys_mkdirat and vfs_mkdir, but we only do a single component lookup
710 * inside this filesystem so it's quite a bit simpler.
711 */
76dda93c
YZ		 712static noinline int btrfs_mksubvol(struct path *parent,
713 char *name, int namelen,
72fd032e 714 struct btrfs_root *snap_src,
6f72c7e2 715 u64 *async_transid, bool readonly,
8696c533 716 struct btrfs_qgroup_inherit *inherit)
cb8e7090 717{
76dda93c 718 struct inode *dir = parent->dentry->d_inode;
cb8e7090
CH		 719 struct dentry *dentry;
720 int error;
721
76dda93c 722 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
cb8e7090
CH		 723
724 dentry = lookup_one_len(name, parent->dentry, namelen);
725 error = PTR_ERR(dentry);
726 if (IS_ERR(dentry))
727 goto out_unlock;
728
729 error = -EEXIST;
730 if (dentry->d_inode)
731 goto out_dput;
732
76dda93c 733 error = btrfs_may_create(dir, dentry);
cb8e7090 734 if (error)
a874a63e 735 goto out_dput;
cb8e7090 736
9c52057c
CM		 737 /*
738 * even if this name doesn't exist, we may get hash collisions.
739 * check for them now when we can safely fail
740 */
741 error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
742 dir->i_ino, name,
743 namelen);
744 if (error)
745 goto out_dput;
746
76dda93c
YZ		 747 down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
748
749 if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
750 goto out_up_read;
751
3de4586c 752 if (snap_src) {
e9662f70 753 error = create_snapshot(snap_src, dir, dentry, name, namelen,
6f72c7e2 754 async_transid, readonly, inherit);
3de4586c 755 } else {
d5c12070
MX		 756 error = create_subvol(dir, dentry, name, namelen,
757 async_transid, inherit);
3de4586c 758 }
76dda93c
YZ		 759 if (!error)
760 fsnotify_mkdir(dir, dentry);
761out_up_read:
762 up_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
cb8e7090
CH		 763out_dput:
764 dput(dentry);
765out_unlock:
76dda93c 766 mutex_unlock(&dir->i_mutex);
cb8e7090
CH		 767 return error;
768}
769
4cb5300b
CM		 770/*
771 * When we're defragging a range, we don't want to kick it off again
772 * if it is really just waiting for delalloc to send it down.
773 * If we find a nice big extent or delalloc range for the bytes in the
774 * file you want to defrag, we return 0 to let you know to skip this
775 * part of the file
776 */
777static int check_defrag_in_cache(struct inode *inode, u64 offset, int thresh)
778{
779 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
780 struct extent_map *em = NULL;
781 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
782 u64 end;
783
784 read_lock(&em_tree->lock);
785 em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
786 read_unlock(&em_tree->lock);
787
788 if (em) {
789 end = extent_map_end(em);
790 free_extent_map(em);
791 if (end - offset > thresh)
792 return 0;
793 }
794 /* if we already have a nice delalloc here, just stop */
795 thresh /= 2;
796 end = count_range_bits(io_tree, &offset, offset + thresh,
797 thresh, EXTENT_DELALLOC, 1);
798 if (end >= thresh)
799 return 0;
800 return 1;
801}
802
803/*
804 * helper function to walk through a file and find extents
805 * newer than a specific transid, and smaller than thresh.
806 *
807 * This is used by the defragging code to find new and small
808 * extents
809 */
810static int find_new_extents(struct btrfs_root *root,
811 struct inode *inode, u64 newer_than,
812 u64 *off, int thresh)
813{
814 struct btrfs_path *path;
815 struct btrfs_key min_key;
816 struct btrfs_key max_key;
817 struct extent_buffer *leaf;
818 struct btrfs_file_extent_item *extent;
819 int type;
820 int ret;
a4689d2b 821 u64 ino = btrfs_ino(inode);
4cb5300b
CM		 822
823 path = btrfs_alloc_path();
824 if (!path)
825 return -ENOMEM;
826
a4689d2b 827 min_key.objectid = ino;
4cb5300b
CM		 828 min_key.type = BTRFS_EXTENT_DATA_KEY;
829 min_key.offset = *off;
830
a4689d2b 831 max_key.objectid = ino;
4cb5300b
CM		 832 max_key.type = (u8)-1;
833 max_key.offset = (u64)-1;
834
835 path->keep_locks = 1;
836
837 while(1) {
838 ret = btrfs_search_forward(root, &min_key, &max_key,
de78b51a 839 path, newer_than);
4cb5300b
CM		 840 if (ret != 0)
841 goto none;
a4689d2b 842 if (min_key.objectid != ino)
4cb5300b
CM		 843 goto none;
844 if (min_key.type != BTRFS_EXTENT_DATA_KEY)
845 goto none;
846
847 leaf = path->nodes[0];
848 extent = btrfs_item_ptr(leaf, path->slots[0],
849 struct btrfs_file_extent_item);
850
851 type = btrfs_file_extent_type(leaf, extent);
852 if (type == BTRFS_FILE_EXTENT_REG &&
853 btrfs_file_extent_num_bytes(leaf, extent) < thresh &&
854 check_defrag_in_cache(inode, min_key.offset, thresh)) {
855 *off = min_key.offset;
856 btrfs_free_path(path);
857 return 0;
858 }
859
860 if (min_key.offset == (u64)-1)
861 goto none;
862
863 min_key.offset++;
864 btrfs_release_path(path);
865 }
866none:
867 btrfs_free_path(path);
868 return -ENOENT;
869}
870
6c282eb4 871static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
17ce6ef8
LB		 872{
873 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
6c282eb4
LZ		 874 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
875 struct extent_map *em;
876 u64 len = PAGE_CACHE_SIZE;
17ce6ef8 877
6c282eb4
LZ		 878 /*
879 * hopefully we have this extent in the tree already, try without
880 * the full extent lock
881 */
17ce6ef8 882 read_lock(&em_tree->lock);
6c282eb4 883 em = lookup_extent_mapping(em_tree, start, len);
17ce6ef8
LB		 884 read_unlock(&em_tree->lock);
885
6c282eb4
LZ		 886 if (!em) {
887 /* get the big lock and read metadata off disk */
888 lock_extent(io_tree, start, start + len - 1);
889 em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
890 unlock_extent(io_tree, start, start + len - 1);
891
892 if (IS_ERR(em))
893 return NULL;
894 }
895
896 return em;
897}
17ce6ef8 898
6c282eb4
LZ		 899static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
900{
901 struct extent_map *next;
902 bool ret = true;
903
904 /* this is the last extent */
905 if (em->start + em->len >= i_size_read(inode))
906 return false;
907
908 next = defrag_lookup_extent(inode, em->start + em->len);
909 if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE)
910 ret = false;
911
912 free_extent_map(next);
17ce6ef8
LB		 913 return ret;
914}
915
6c282eb4 916static int should_defrag_range(struct inode *inode, u64 start, int thresh,
a43a2111
AM		 917 u64 *last_len, u64 *skip, u64 *defrag_end,
918 int compress)
940100a4 919{
6c282eb4 920 struct extent_map *em;
940100a4 921 int ret = 1;
6c282eb4 922 bool next_mergeable = true;
940100a4
CM		 923
924 /*
008873ea 925 * make sure that once we start defragging an extent, we keep on
940100a4
CM		 926 * defragging it
927 */
928 if (start < *defrag_end)
929 return 1;
930
931 *skip = 0;
932
6c282eb4
LZ		 933 em = defrag_lookup_extent(inode, start);
934 if (!em)
935 return 0;
940100a4
CM		 936
937 /* this will cover holes, and inline extents */
17ce6ef8 938 if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
940100a4 939 ret = 0;
17ce6ef8
LB		 940 goto out;
941 }
942
6c282eb4 943 next_mergeable = defrag_check_next_extent(inode, em);
940100a4
CM		 944
945 /*
6c282eb4
LZ		 946 * we hit a real extent, if it is big or the next extent is not a
947 * real extent, don't bother defragging it
940100a4 948 */
a43a2111 949 if (!compress && (*last_len == 0 || *last_len >= thresh) &&
6c282eb4 950 (em->len >= thresh || !next_mergeable))
940100a4 951 ret = 0;
17ce6ef8 952out:
940100a4
CM		 953 /*
954 * last_len ends up being a counter of how many bytes we've defragged.
955 * every time we choose not to defrag an extent, we reset *last_len
956 * so that the next tiny extent will force a defrag.
957 *
958 * The end result of this is that tiny extents before a single big
959 * extent will force at least part of that big extent to be defragged.
960 */
961 if (ret) {
940100a4
CM		 962 *defrag_end = extent_map_end(em);
963 } else {
964 *last_len = 0;
965 *skip = extent_map_end(em);
966 *defrag_end = 0;
967 }
968
969 free_extent_map(em);
970 return ret;
971}
972
4cb5300b
CM		 973/*
974 * it doesn't do much good to defrag one or two pages
975 * at a time. This pulls in a nice chunk of pages
976 * to COW and defrag.
977 *
978 * It also makes sure the delalloc code has enough
979 * dirty data to avoid making new small extents as part
980 * of the defrag
981 *
982 * It's a good idea to start RA on this range
983 * before calling this.
984 */
985static int cluster_pages_for_defrag(struct inode *inode,
986 struct page **pages,
987 unsigned long start_index,
988 int num_pages)
f46b5a66 989{
4cb5300b
CM		 990 unsigned long file_end;
991 u64 isize = i_size_read(inode);
992 u64 page_start;
993 u64 page_end;
1f12bd06 994 u64 page_cnt;
4cb5300b
CM		 995 int ret;
996 int i;
997 int i_done;
3eaa2885 998 struct btrfs_ordered_extent *ordered;
4cb5300b 999 struct extent_state *cached_state = NULL;
600a45e1 1000 struct extent_io_tree *tree;
3b16a4e3 1001 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
4cb5300b 1002
4cb5300b 1003 file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
1f12bd06
LB		 1004 if (!isize || start_index > file_end)
1005 return 0;
1006
1007 page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1);
4cb5300b
CM		 1008
1009 ret = btrfs_delalloc_reserve_space(inode,
1f12bd06 1010 page_cnt << PAGE_CACHE_SHIFT);
4cb5300b
CM		 1011 if (ret)
1012 return ret;
4cb5300b 1013 i_done = 0;
600a45e1 1014 tree = &BTRFS_I(inode)->io_tree;
4cb5300b
CM		 1015
1016 /* step one, lock all the pages */
1f12bd06 1017 for (i = 0; i < page_cnt; i++) {
4cb5300b 1018 struct page *page;
600a45e1 1019again:
a94733d0 1020 page = find_or_create_page(inode->i_mapping,
600a45e1 1021 start_index + i, mask);
4cb5300b
CM		 1022 if (!page)
1023 break;
1024
600a45e1
MX		 1025 page_start = page_offset(page);
1026 page_end = page_start + PAGE_CACHE_SIZE - 1;
1027 while (1) {
d0082371 1028 lock_extent(tree, page_start, page_end);
600a45e1
MX		 1029 ordered = btrfs_lookup_ordered_extent(inode,
1030 page_start);
d0082371 1031 unlock_extent(tree, page_start, page_end);
600a45e1
MX		 1032 if (!ordered)
1033 break;
1034
1035 unlock_page(page);
1036 btrfs_start_ordered_extent(inode, ordered, 1);
1037 btrfs_put_ordered_extent(ordered);
1038 lock_page(page);
1f12bd06
LB		 1039 /*
1040 * we unlocked the page above, so we need check if
1041 * it was released or not.
1042 */
1043 if (page->mapping != inode->i_mapping) {
1044 unlock_page(page);
1045 page_cache_release(page);
1046 goto again;
1047 }
600a45e1
MX		 1048 }
1049
4cb5300b
CM		 1050 if (!PageUptodate(page)) {
1051 btrfs_readpage(NULL, page);
1052 lock_page(page);
1053 if (!PageUptodate(page)) {
1054 unlock_page(page);
1055 page_cache_release(page);
1056 ret = -EIO;
1057 break;
1058 }
1059 }
600a45e1 1060
600a45e1
MX		 1061 if (page->mapping != inode->i_mapping) {
1062 unlock_page(page);
1063 page_cache_release(page);
1064 goto again;
1065 }
1066
4cb5300b
CM		 1067 pages[i] = page;
1068 i_done++;
1069 }
1070 if (!i_done || ret)
1071 goto out;
1072
1073 if (!(inode->i_sb->s_flags & MS_ACTIVE))
1074 goto out;
1075
1076 /*
1077 * so now we have a nice long stream of locked
1078 * and up to date pages, lets wait on them
1079 */
1080 for (i = 0; i < i_done; i++)
1081 wait_on_page_writeback(pages[i]);
1082
1083 page_start = page_offset(pages[0]);
1084 page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;
1085
1086 lock_extent_bits(&BTRFS_I(inode)->io_tree,
d0082371 1087 page_start, page_end - 1, 0, &cached_state);
4cb5300b
CM		 1088 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
1089 page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
9e8a4a8b
LB		 1090 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
1091 &cached_state, GFP_NOFS);
4cb5300b 1092
1f12bd06 1093 if (i_done != page_cnt) {
9e0baf60
JB		 1094 spin_lock(&BTRFS_I(inode)->lock);
1095 BTRFS_I(inode)->outstanding_extents++;
1096 spin_unlock(&BTRFS_I(inode)->lock);
4cb5300b 1097 btrfs_delalloc_release_space(inode,
1f12bd06 1098 (page_cnt - i_done) << PAGE_CACHE_SHIFT);
4cb5300b
CM		 1099 }
1100
1101
9e8a4a8b
LB		 1102 set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
1103 &cached_state, GFP_NOFS);
4cb5300b
CM		 1104
1105 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1106 page_start, page_end - 1, &cached_state,
1107 GFP_NOFS);
1108
1109 for (i = 0; i < i_done; i++) {
1110 clear_page_dirty_for_io(pages[i]);
1111 ClearPageChecked(pages[i]);
1112 set_page_extent_mapped(pages[i]);
1113 set_page_dirty(pages[i]);
1114 unlock_page(pages[i]);
1115 page_cache_release(pages[i]);
1116 }
1117 return i_done;
1118out:
1119 for (i = 0; i < i_done; i++) {
1120 unlock_page(pages[i]);
1121 page_cache_release(pages[i]);
1122 }
1f12bd06 1123 btrfs_delalloc_release_space(inode, page_cnt << PAGE_CACHE_SHIFT);
4cb5300b
CM		 1124 return ret;
1125
1126}
1127
1128int btrfs_defrag_file(struct inode *inode, struct file *file,
1129 struct btrfs_ioctl_defrag_range_args *range,
1130 u64 newer_than, unsigned long max_to_defrag)
1131{
1132 struct btrfs_root *root = BTRFS_I(inode)->root;
4cb5300b 1133 struct file_ra_state *ra = NULL;
f46b5a66 1134 unsigned long last_index;
151a31b2 1135 u64 isize = i_size_read(inode);
940100a4
CM		 1136 u64 last_len = 0;
1137 u64 skip = 0;
1138 u64 defrag_end = 0;
4cb5300b 1139 u64 newer_off = range->start;
f46b5a66 1140 unsigned long i;
008873ea 1141 unsigned long ra_index = 0;
f46b5a66 1142 int ret;
4cb5300b 1143 int defrag_count = 0;
1a419d85 1144 int compress_type = BTRFS_COMPRESS_ZLIB;
4cb5300b 1145 int extent_thresh = range->extent_thresh;
008873ea
LZ		 1146 int max_cluster = (256 * 1024) >> PAGE_CACHE_SHIFT;
1147 int cluster = max_cluster;
4cb5300b
CM		 1148 u64 new_align = ~((u64)128 * 1024 - 1);
1149 struct page **pages = NULL;
1150
1151 if (extent_thresh == 0)
1152 extent_thresh = 256 * 1024;
1a419d85
LZ		 1153
1154 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS) {
1155 if (range->compress_type > BTRFS_COMPRESS_TYPES)
1156 return -EINVAL;
1157 if (range->compress_type)
1158 compress_type = range->compress_type;
1159 }
f46b5a66 1160
151a31b2 1161 if (isize == 0)
940100a4
CM		 1162 return 0;
1163
4cb5300b
CM		 1164 /*
1165 * if we were not given a file, allocate a readahead
1166 * context
1167 */
1168 if (!file) {
1169 ra = kzalloc(sizeof(*ra), GFP_NOFS);
1170 if (!ra)
1171 return -ENOMEM;
1172 file_ra_state_init(ra, inode->i_mapping);
1173 } else {
1174 ra = &file->f_ra;
1175 }
1176
008873ea 1177 pages = kmalloc(sizeof(struct page *) * max_cluster,
4cb5300b
CM		 1178 GFP_NOFS);
1179 if (!pages) {
1180 ret = -ENOMEM;
1181 goto out_ra;
1182 }
1183
1184 /* find the last page to defrag */
1e701a32 1185 if (range->start + range->len > range->start) {
151a31b2 1186 last_index = min_t(u64, isize - 1,
1e701a32
CM		 1187 range->start + range->len - 1) >> PAGE_CACHE_SHIFT;
1188 } else {
151a31b2 1189 last_index = (isize - 1) >> PAGE_CACHE_SHIFT;
1e701a32
CM		 1190 }
1191
4cb5300b
CM		 1192 if (newer_than) {
1193 ret = find_new_extents(root, inode, newer_than,
1194 &newer_off, 64 * 1024);
1195 if (!ret) {
1196 range->start = newer_off;
1197 /*
1198 * we always align our defrag to help keep
1199 * the extents in the file evenly spaced
1200 */
1201 i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
4cb5300b
CM		 1202 } else
1203 goto out_ra;
1204 } else {
1205 i = range->start >> PAGE_CACHE_SHIFT;
1206 }
1207 if (!max_to_defrag)
7ec31b54 1208 max_to_defrag = last_index + 1;
4cb5300b 1209
2a0f7f57
LZ		 1210 /*
1211 * make writeback starts from i, so the defrag range can be
1212 * written sequentially.
1213 */
1214 if (i < inode->i_mapping->writeback_index)
1215 inode->i_mapping->writeback_index = i;
1216
f7f43cc8
CM		 1217 while (i <= last_index && defrag_count < max_to_defrag &&
1218 (i < (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
1219 PAGE_CACHE_SHIFT)) {
4cb5300b
CM		 1220 /*
1221 * make sure we stop running if someone unmounts
1222 * the FS
1223 */
1224 if (!(inode->i_sb->s_flags & MS_ACTIVE))
1225 break;
1226
210549eb
DS		 1227 if (btrfs_defrag_cancelled(root->fs_info)) {
1228 printk(KERN_DEBUG "btrfs: defrag_file cancelled\n");
1229 ret = -EAGAIN;
1230 break;
1231 }
1232
66c26892 1233 if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
6c282eb4 1234 extent_thresh, &last_len, &skip,
a43a2111
AM		 1235 &defrag_end, range->flags &
1236 BTRFS_DEFRAG_RANGE_COMPRESS)) {
940100a4
CM		 1237 unsigned long next;
1238 /*
1239 * the should_defrag function tells us how much to skip
1240 * bump our counter by the suggested amount
1241 */
1242 next = (skip + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
1243 i = max(i + 1, next);
1244 continue;
1245 }
008873ea
LZ		 1246
1247 if (!newer_than) {
1248 cluster = (PAGE_CACHE_ALIGN(defrag_end) >>
1249 PAGE_CACHE_SHIFT) - i;
1250 cluster = min(cluster, max_cluster);
1251 } else {
1252 cluster = max_cluster;
1253 }
1254
1e701a32 1255 if (range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)
1a419d85 1256 BTRFS_I(inode)->force_compress = compress_type;
940100a4 1257
008873ea
LZ		 1258 if (i + cluster > ra_index) {
1259 ra_index = max(i, ra_index);
1260 btrfs_force_ra(inode->i_mapping, ra, file, ra_index,
1261 cluster);
1262 ra_index += max_cluster;
1263 }
940100a4 1264
ecb8bea8 1265 mutex_lock(&inode->i_mutex);
008873ea 1266 ret = cluster_pages_for_defrag(inode, pages, i, cluster);
ecb8bea8
LB		 1267 if (ret < 0) {
1268 mutex_unlock(&inode->i_mutex);
4cb5300b 1269 goto out_ra;
ecb8bea8 1270 }
4cb5300b
CM		 1271
1272 defrag_count += ret;
d0e1d66b 1273 balance_dirty_pages_ratelimited(inode->i_mapping);
ecb8bea8 1274 mutex_unlock(&inode->i_mutex);
4cb5300b
CM		 1275
1276 if (newer_than) {
1277 if (newer_off == (u64)-1)
1278 break;
1279
e1f041e1
LB		 1280 if (ret > 0)
1281 i += ret;
1282
4cb5300b
CM		 1283 newer_off = max(newer_off + 1,
1284 (u64)i << PAGE_CACHE_SHIFT);
1285
1286 ret = find_new_extents(root, inode,
1287 newer_than, &newer_off,
1288 64 * 1024);
1289 if (!ret) {
1290 range->start = newer_off;
1291 i = (newer_off & new_align) >> PAGE_CACHE_SHIFT;
4cb5300b
CM		 1292 } else {
1293 break;
f46b5a66 1294 }
4cb5300b 1295 } else {
008873ea 1296 if (ret > 0) {
cbcc8326 1297 i += ret;
008873ea
LZ		 1298 last_len += ret << PAGE_CACHE_SHIFT;
1299 } else {
cbcc8326 1300 i++;
008873ea
LZ		 1301 last_len = 0;
1302 }
f46b5a66 1303 }
f46b5a66
CH		 1304 }
1305
1e701a32
CM		 1306 if ((range->flags & BTRFS_DEFRAG_RANGE_START_IO))
1307 filemap_flush(inode->i_mapping);
1308
1309 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
1310 /* the filemap_flush will queue IO into the worker threads, but
1311 * we have to make sure the IO is actually started and that
1312 * ordered extents get created before we return
1313 */
1314 atomic_inc(&root->fs_info->async_submit_draining);
1315 while (atomic_read(&root->fs_info->nr_async_submits) ||
1316 atomic_read(&root->fs_info->async_delalloc_pages)) {
1317 wait_event(root->fs_info->async_submit_wait,
1318 (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
1319 atomic_read(&root->fs_info->async_delalloc_pages) == 0));
1320 }
1321 atomic_dec(&root->fs_info->async_submit_draining);
1322
1323 mutex_lock(&inode->i_mutex);
261507a0 1324 BTRFS_I(inode)->force_compress = BTRFS_COMPRESS_NONE;
1e701a32
CM		 1325 mutex_unlock(&inode->i_mutex);
1326 }
1327
1a419d85 1328 if (range->compress_type == BTRFS_COMPRESS_LZO) {
2b0ce2c2 1329 btrfs_set_fs_incompat(root->fs_info, COMPRESS_LZO);
1a419d85
LZ		 1330 }
1331
60ccf82f 1332 ret = defrag_count;
940100a4 1333
4cb5300b
CM		 1334out_ra:
1335 if (!file)
1336 kfree(ra);
1337 kfree(pages);
940100a4 1338 return ret;
f46b5a66
CH		 1339}
1340
198605a8 1341static noinline int btrfs_ioctl_resize(struct file *file,
76dda93c 1342 void __user *arg)
f46b5a66
CH		 1343{
1344 u64 new_size;
1345 u64 old_size;
1346 u64 devid = 1;
198605a8 1347 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
f46b5a66
CH		 1348 struct btrfs_ioctl_vol_args *vol_args;
1349 struct btrfs_trans_handle *trans;
1350 struct btrfs_device *device = NULL;
1351 char *sizestr;
1352 char *devstr = NULL;
1353 int ret = 0;
f46b5a66
CH		 1354 int mod = 0;
1355
e441d54d
CM		 1356 if (!capable(CAP_SYS_ADMIN))
1357 return -EPERM;
1358
198605a8
MX		 1359 ret = mnt_want_write_file(file);
1360 if (ret)
1361 return ret;
1362
5ac00add
SB		 1363 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
1364 1)) {
1365 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
97547676 1366 mnt_drop_write_file(file);
2c0c9da0 1367 return -EINVAL;
c9e9f97b
ID		 1368 }
1369
5ac00add 1370 mutex_lock(&root->fs_info->volume_mutex);
dae7b665 1371 vol_args = memdup_user(arg, sizeof(*vol_args));
c9e9f97b
ID		 1372 if (IS_ERR(vol_args)) {
1373 ret = PTR_ERR(vol_args);
1374 goto out;
1375 }
5516e595
MF		 1376
1377 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
f46b5a66 1378
f46b5a66
CH		 1379 sizestr = vol_args->name;
1380 devstr = strchr(sizestr, ':');
1381 if (devstr) {
1382 char *end;
1383 sizestr = devstr + 1;
1384 *devstr = '\0';
1385 devstr = vol_args->name;
1386 devid = simple_strtoull(devstr, &end, 10);
dfd79829
MX		 1387 if (!devid) {
1388 ret = -EINVAL;
1389 goto out_free;
1390 }
5bb14682 1391 printk(KERN_INFO "btrfs: resizing devid %llu\n",
21380931 1392 (unsigned long long)devid);
f46b5a66 1393 }
dba60f3f 1394
aa1b8cd4 1395 device = btrfs_find_device(root->fs_info, devid, NULL, NULL);
f46b5a66 1396 if (!device) {
5bb14682 1397 printk(KERN_INFO "btrfs: resizer unable to find device %llu\n",
21380931 1398 (unsigned long long)devid);
dfd79829 1399 ret = -ENODEV;
c9e9f97b 1400 goto out_free;
f46b5a66 1401 }
dba60f3f
MX		 1402
1403 if (!device->writeable) {
4e42ae1b 1404 printk(KERN_INFO "btrfs: resizer unable to apply on "
dba60f3f 1405 "readonly device %llu\n",
a8c4a33b 1406 (unsigned long long)devid);
dfd79829 1407 ret = -EPERM;
4e42ae1b
LB		 1408 goto out_free;
1409 }
1410
f46b5a66
CH		 1411 if (!strcmp(sizestr, "max"))
1412 new_size = device->bdev->bd_inode->i_size;
1413 else {
1414 if (sizestr[0] == '-') {
1415 mod = -1;
1416 sizestr++;
1417 } else if (sizestr[0] == '+') {
1418 mod = 1;
1419 sizestr++;
1420 }
91748467 1421 new_size = memparse(sizestr, NULL);
f46b5a66
CH		 1422 if (new_size == 0) {
1423 ret = -EINVAL;
c9e9f97b 1424 goto out_free;
f46b5a66
CH		 1425 }
1426 }
1427
63a212ab 1428 if (device->is_tgtdev_for_dev_replace) {
dfd79829 1429 ret = -EPERM;
63a212ab
SB		 1430 goto out_free;
1431 }
1432
f46b5a66
CH		 1433 old_size = device->total_bytes;
1434
1435 if (mod < 0) {
1436 if (new_size > old_size) {
1437 ret = -EINVAL;
c9e9f97b 1438 goto out_free;
f46b5a66
CH		 1439 }
1440 new_size = old_size - new_size;
1441 } else if (mod > 0) {
1442 new_size = old_size + new_size;
1443 }
1444
1445 if (new_size < 256 * 1024 * 1024) {
1446 ret = -EINVAL;
c9e9f97b 1447 goto out_free;
f46b5a66
CH		 1448 }
1449 if (new_size > device->bdev->bd_inode->i_size) {
1450 ret = -EFBIG;
c9e9f97b 1451 goto out_free;
f46b5a66
CH		 1452 }
1453
1454 do_div(new_size, root->sectorsize);
1455 new_size *= root->sectorsize;
1456
606686ee
JB		 1457 printk_in_rcu(KERN_INFO "btrfs: new size for %s is %llu\n",
1458 rcu_str_deref(device->name),
1459 (unsigned long long)new_size);
f46b5a66
CH		 1460
1461 if (new_size > old_size) {
a22285a6 1462 trans = btrfs_start_transaction(root, 0);
98d5dc13
TI		 1463 if (IS_ERR(trans)) {
1464 ret = PTR_ERR(trans);
c9e9f97b 1465 goto out_free;
98d5dc13 1466 }
f46b5a66
CH		 1467 ret = btrfs_grow_device(trans, device, new_size);
1468 btrfs_commit_transaction(trans, root);
ece7d20e 1469 } else if (new_size < old_size) {
f46b5a66 1470 ret = btrfs_shrink_device(device, new_size);
0253f40e 1471 } /* equal, nothing need to do */
f46b5a66 1472
c9e9f97b 1473out_free:
f46b5a66 1474 kfree(vol_args);
c9e9f97b
ID		 1475out:
1476 mutex_unlock(&root->fs_info->volume_mutex);
5ac00add 1477 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
18f39c41 1478 mnt_drop_write_file(file);
f46b5a66
CH		 1479 return ret;
1480}
1481
72fd032e 1482static noinline int btrfs_ioctl_snap_create_transid(struct file *file,
6f72c7e2
AJ		 1483 char *name, unsigned long fd, int subvol,
1484 u64 *transid, bool readonly,
8696c533 1485 struct btrfs_qgroup_inherit *inherit)
f46b5a66 1486{
f46b5a66 1487 int namelen;
3de4586c 1488 int ret = 0;
f46b5a66 1489
a874a63e
LB		 1490 ret = mnt_want_write_file(file);
1491 if (ret)
1492 goto out;
1493
72fd032e
SW		 1494 namelen = strlen(name);
1495 if (strchr(name, '/')) {
f46b5a66 1496 ret = -EINVAL;
a874a63e 1497 goto out_drop_write;
f46b5a66
CH		 1498 }
1499
16780cab
CM		 1500 if (name[0] == '.' &&
1501 (namelen == 1 || (name[1] == '.' && namelen == 2))) {
1502 ret = -EEXIST;
a874a63e 1503 goto out_drop_write;
16780cab
CM		 1504 }
1505
3de4586c 1506 if (subvol) {
72fd032e 1507 ret = btrfs_mksubvol(&file->f_path, name, namelen,
6f72c7e2 1508 NULL, transid, readonly, inherit);
cb8e7090 1509 } else {
2903ff01 1510 struct fd src = fdget(fd);
3de4586c 1511 struct inode *src_inode;
2903ff01 1512 if (!src.file) {
3de4586c 1513 ret = -EINVAL;
a874a63e 1514 goto out_drop_write;
3de4586c
CM		 1515 }
1516
2903ff01 1517 src_inode = src.file->f_path.dentry->d_inode;
3de4586c 1518 if (src_inode->i_sb != file->f_path.dentry->d_inode->i_sb) {
d397712b
CM		 1519 printk(KERN_INFO "btrfs: Snapshot src from "
1520 "another FS\n");
3de4586c 1521 ret = -EINVAL;
ecd18815
AV		 1522 } else {
1523 ret = btrfs_mksubvol(&file->f_path, name, namelen,
1524 BTRFS_I(src_inode)->root,
1525 transid, readonly, inherit);
3de4586c 1526 }
2903ff01 1527 fdput(src);
cb8e7090 1528 }
a874a63e
LB		 1529out_drop_write:
1530 mnt_drop_write_file(file);
f46b5a66 1531out:
72fd032e
SW		 1532 return ret;
1533}
1534
1535static noinline int btrfs_ioctl_snap_create(struct file *file,
fa0d2b9b 1536 void __user *arg, int subvol)
72fd032e 1537{
fa0d2b9b 1538 struct btrfs_ioctl_vol_args *vol_args;
72fd032e
SW		 1539 int ret;
1540
fa0d2b9b
LZ		 1541 vol_args = memdup_user(arg, sizeof(*vol_args));
1542 if (IS_ERR(vol_args))
1543 return PTR_ERR(vol_args);
1544 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
72fd032e 1545
fa0d2b9b 1546 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
b83cc969 1547 vol_args->fd, subvol,
6f72c7e2 1548 NULL, false, NULL);
fdfb1e4f 1549
fa0d2b9b
LZ		 1550 kfree(vol_args);
1551 return ret;
1552}
fdfb1e4f 1553
fa0d2b9b
LZ		 1554static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
1555 void __user *arg, int subvol)
1556{
1557 struct btrfs_ioctl_vol_args_v2 *vol_args;
1558 int ret;
1559 u64 transid = 0;
1560 u64 *ptr = NULL;
b83cc969 1561 bool readonly = false;
6f72c7e2 1562 struct btrfs_qgroup_inherit *inherit = NULL;
75eaa0e2 1563
fa0d2b9b
LZ		 1564 vol_args = memdup_user(arg, sizeof(*vol_args));
1565 if (IS_ERR(vol_args))
1566 return PTR_ERR(vol_args);
1567 vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
75eaa0e2 1568
b83cc969 1569 if (vol_args->flags &
6f72c7e2
AJ		 1570 ~(BTRFS_SUBVOL_CREATE_ASYNC | BTRFS_SUBVOL_RDONLY |
1571 BTRFS_SUBVOL_QGROUP_INHERIT)) {
b83cc969 1572 ret = -EOPNOTSUPP;
fa0d2b9b 1573 goto out;
72fd032e 1574 }
fa0d2b9b
LZ		 1575
1576 if (vol_args->flags & BTRFS_SUBVOL_CREATE_ASYNC)
1577 ptr = &transid;
b83cc969
LZ		 1578 if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
1579 readonly = true;
6f72c7e2
AJ		 1580 if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
1581 if (vol_args->size > PAGE_CACHE_SIZE) {
1582 ret = -EINVAL;
1583 goto out;
1584 }
1585 inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size);
1586 if (IS_ERR(inherit)) {
1587 ret = PTR_ERR(inherit);
1588 goto out;
1589 }
1590 }
fa0d2b9b
LZ		 1591
1592 ret = btrfs_ioctl_snap_create_transid(file, vol_args->name,
6f72c7e2 1593 vol_args->fd, subvol, ptr,
8696c533 1594 readonly, inherit);
fa0d2b9b
LZ		 1595
1596 if (ret == 0 && ptr &&
1597 copy_to_user(arg +
1598 offsetof(struct btrfs_ioctl_vol_args_v2,
1599 transid), ptr, sizeof(*ptr)))
1600 ret = -EFAULT;
fdfb1e4f 1601out:
f46b5a66 1602 kfree(vol_args);
6f72c7e2 1603 kfree(inherit);
f46b5a66
CH		 1604 return ret;
1605}
1606
0caa102d
LZ		 1607static noinline int btrfs_ioctl_subvol_getflags(struct file *file,
1608 void __user *arg)
1609{
1610 struct inode *inode = fdentry(file)->d_inode;
1611 struct btrfs_root *root = BTRFS_I(inode)->root;
1612 int ret = 0;
1613 u64 flags = 0;
1614
33345d01 1615 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID)
0caa102d
LZ		 1616 return -EINVAL;
1617
1618 down_read(&root->fs_info->subvol_sem);
1619 if (btrfs_root_readonly(root))
1620 flags |= BTRFS_SUBVOL_RDONLY;
1621 up_read(&root->fs_info->subvol_sem);
1622
1623 if (copy_to_user(arg, &flags, sizeof(flags)))
1624 ret = -EFAULT;
1625
1626 return ret;
1627}
1628
1629static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
1630 void __user *arg)
1631{
1632 struct inode *inode = fdentry(file)->d_inode;
1633 struct btrfs_root *root = BTRFS_I(inode)->root;
1634 struct btrfs_trans_handle *trans;
1635 u64 root_flags;
1636 u64 flags;
1637 int ret = 0;
1638
b9ca0664
LB		 1639 ret = mnt_want_write_file(file);
1640 if (ret)
1641 goto out;
0caa102d 1642
b9ca0664
LB		 1643 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
1644 ret = -EINVAL;
1645 goto out_drop_write;
1646 }
0caa102d 1647
b9ca0664
LB		 1648 if (copy_from_user(&flags, arg, sizeof(flags))) {
1649 ret = -EFAULT;
1650 goto out_drop_write;
1651 }
0caa102d 1652
b9ca0664
LB		 1653 if (flags & BTRFS_SUBVOL_CREATE_ASYNC) {
1654 ret = -EINVAL;
1655 goto out_drop_write;
1656 }
0caa102d 1657
b9ca0664
LB		 1658 if (flags & ~BTRFS_SUBVOL_RDONLY) {
1659 ret = -EOPNOTSUPP;
1660 goto out_drop_write;
1661 }
0caa102d 1662
b9ca0664
LB		 1663 if (!inode_owner_or_capable(inode)) {
1664 ret = -EACCES;
1665 goto out_drop_write;
1666 }
b4dc2b8c 1667
0caa102d
LZ		 1668 down_write(&root->fs_info->subvol_sem);
1669
1670 /* nothing to do */
1671 if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
b9ca0664 1672 goto out_drop_sem;
0caa102d
LZ		 1673
1674 root_flags = btrfs_root_flags(&root->root_item);
1675 if (flags & BTRFS_SUBVOL_RDONLY)
1676 btrfs_set_root_flags(&root->root_item,
1677 root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
1678 else
1679 btrfs_set_root_flags(&root->root_item,
1680 root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
1681
1682 trans = btrfs_start_transaction(root, 1);
1683 if (IS_ERR(trans)) {
1684 ret = PTR_ERR(trans);
1685 goto out_reset;
1686 }
1687
b4dc2b8c 1688 ret = btrfs_update_root(trans, root->fs_info->tree_root,
0caa102d
LZ		 1689 &root->root_key, &root->root_item);
1690
1691 btrfs_commit_transaction(trans, root);
1692out_reset:
1693 if (ret)
1694 btrfs_set_root_flags(&root->root_item, root_flags);
b9ca0664 1695out_drop_sem:
0caa102d 1696 up_write(&root->fs_info->subvol_sem);
b9ca0664
LB		 1697out_drop_write:
1698 mnt_drop_write_file(file);
1699out:
0caa102d
LZ		 1700 return ret;
1701}
1702
76dda93c
YZ		 1703/*
1704 * helper to check if the subvolume references other subvolumes
1705 */
1706static noinline int may_destroy_subvol(struct btrfs_root *root)
1707{
1708 struct btrfs_path *path;
1709 struct btrfs_key key;
1710 int ret;
1711
1712 path = btrfs_alloc_path();
1713 if (!path)
1714 return -ENOMEM;
1715
1716 key.objectid = root->root_key.objectid;
1717 key.type = BTRFS_ROOT_REF_KEY;
1718 key.offset = (u64)-1;
1719
1720 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
1721 &key, path, 0, 0);
1722 if (ret < 0)
1723 goto out;
1724 BUG_ON(ret == 0);
1725
1726 ret = 0;
1727 if (path->slots[0] > 0) {
1728 path->slots[0]--;
1729 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1730 if (key.objectid == root->root_key.objectid &&
1731 key.type == BTRFS_ROOT_REF_KEY)
1732 ret = -ENOTEMPTY;
1733 }
1734out:
1735 btrfs_free_path(path);
1736 return ret;
1737}
1738
ac8e9819
CM		 1739static noinline int key_in_sk(struct btrfs_key *key,
1740 struct btrfs_ioctl_search_key *sk)
1741{
abc6e134
CM		 1742 struct btrfs_key test;
1743 int ret;
1744
1745 test.objectid = sk->min_objectid;
1746 test.type = sk->min_type;
1747 test.offset = sk->min_offset;
1748
1749 ret = btrfs_comp_cpu_keys(key, &test);
1750 if (ret < 0)
ac8e9819 1751 return 0;
abc6e134
CM		 1752
1753 test.objectid = sk->max_objectid;
1754 test.type = sk->max_type;
1755 test.offset = sk->max_offset;
1756
1757 ret = btrfs_comp_cpu_keys(key, &test);
1758 if (ret > 0)
ac8e9819
CM		 1759 return 0;
1760 return 1;
1761}
1762
1763static noinline int copy_to_sk(struct btrfs_root *root,
1764 struct btrfs_path *path,
1765 struct btrfs_key *key,
1766 struct btrfs_ioctl_search_key *sk,
1767 char *buf,
1768 unsigned long *sk_offset,
1769 int *num_found)
1770{
1771 u64 found_transid;
1772 struct extent_buffer *leaf;
1773 struct btrfs_ioctl_search_header sh;
1774 unsigned long item_off;
1775 unsigned long item_len;
1776 int nritems;
1777 int i;
1778 int slot;
ac8e9819
CM		 1779 int ret = 0;
1780
1781 leaf = path->nodes[0];
1782 slot = path->slots[0];
1783 nritems = btrfs_header_nritems(leaf);
1784
1785 if (btrfs_header_generation(leaf) > sk->max_transid) {
1786 i = nritems;
1787 goto advance_key;
1788 }
1789 found_transid = btrfs_header_generation(leaf);
1790
1791 for (i = slot; i < nritems; i++) {
1792 item_off = btrfs_item_ptr_offset(leaf, i);
1793 item_len = btrfs_item_size_nr(leaf, i);
1794
1795 if (item_len > BTRFS_SEARCH_ARGS_BUFSIZE)
1796 item_len = 0;
1797
1798 if (sizeof(sh) + item_len + *sk_offset >
1799 BTRFS_SEARCH_ARGS_BUFSIZE) {
1800 ret = 1;
1801 goto overflow;
1802 }
1803
1804 btrfs_item_key_to_cpu(leaf, key, i);
1805 if (!key_in_sk(key, sk))
1806 continue;
1807
1808 sh.objectid = key->objectid;
1809 sh.offset = key->offset;
1810 sh.type = key->type;
1811 sh.len = item_len;
1812 sh.transid = found_transid;
1813
1814 /* copy search result header */
1815 memcpy(buf + *sk_offset, &sh, sizeof(sh));
1816 *sk_offset += sizeof(sh);
1817
1818 if (item_len) {
1819 char *p = buf + *sk_offset;
1820 /* copy the item */
1821 read_extent_buffer(leaf, p,
1822 item_off, item_len);
1823 *sk_offset += item_len;
ac8e9819 1824 }
e2156867 1825 (*num_found)++;
ac8e9819
CM		 1826
1827 if (*num_found >= sk->nr_items)
1828 break;
1829 }
1830advance_key:
abc6e134
CM		 1831 ret = 0;
1832 if (key->offset < (u64)-1 && key->offset < sk->max_offset)
ac8e9819 1833 key->offset++;
abc6e134
CM		 1834 else if (key->type < (u8)-1 && key->type < sk->max_type) {
1835 key->offset = 0;
ac8e9819 1836 key->type++;
abc6e134
CM		 1837 } else if (key->objectid < (u64)-1 && key->objectid < sk->max_objectid) {
1838 key->offset = 0;
1839 key->type = 0;
ac8e9819 1840 key->objectid++;
abc6e134
CM		 1841 } else
1842 ret = 1;
ac8e9819 1843overflow:
ac8e9819
CM		 1844 return ret;
1845}
1846
1847static noinline int search_ioctl(struct inode *inode,
1848 struct btrfs_ioctl_search_args *args)
1849{
1850 struct btrfs_root *root;
1851 struct btrfs_key key;
1852 struct btrfs_key max_key;
1853 struct btrfs_path *path;
1854 struct btrfs_ioctl_search_key *sk = &args->key;
1855 struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info;
1856 int ret;
1857 int num_found = 0;
1858 unsigned long sk_offset = 0;
1859
1860 path = btrfs_alloc_path();
1861 if (!path)
1862 return -ENOMEM;
1863
1864 if (sk->tree_id == 0) {
1865 /* search the root of the inode that was passed */
1866 root = BTRFS_I(inode)->root;
1867 } else {
1868 key.objectid = sk->tree_id;
1869 key.type = BTRFS_ROOT_ITEM_KEY;
1870 key.offset = (u64)-1;
1871 root = btrfs_read_fs_root_no_name(info, &key);
1872 if (IS_ERR(root)) {
1873 printk(KERN_ERR "could not find root %llu\n",
1874 sk->tree_id);
1875 btrfs_free_path(path);
1876 return -ENOENT;
1877 }
1878 }
1879
1880 key.objectid = sk->min_objectid;
1881 key.type = sk->min_type;
1882 key.offset = sk->min_offset;
1883
1884 max_key.objectid = sk->max_objectid;
1885 max_key.type = sk->max_type;
1886 max_key.offset = sk->max_offset;
1887
1888 path->keep_locks = 1;
1889
1890 while(1) {
de78b51a 1891 ret = btrfs_search_forward(root, &key, &max_key, path,
ac8e9819
CM		 1892 sk->min_transid);
1893 if (ret != 0) {
1894 if (ret > 0)
1895 ret = 0;
1896 goto err;
1897 }
1898 ret = copy_to_sk(root, path, &key, sk, args->buf,
1899 &sk_offset, &num_found);
b3b4aa74 1900 btrfs_release_path(path);
ac8e9819
CM		 1901 if (ret || num_found >= sk->nr_items)
1902 break;
1903
1904 }
1905 ret = 0;
1906err:
1907 sk->nr_items = num_found;
1908 btrfs_free_path(path);
1909 return ret;
1910}
1911
1912static noinline int btrfs_ioctl_tree_search(struct file *file,
1913 void __user *argp)
1914{
1915 struct btrfs_ioctl_search_args *args;
1916 struct inode *inode;
1917 int ret;
1918
1919 if (!capable(CAP_SYS_ADMIN))
1920 return -EPERM;
1921
2354d08f
JL		 1922 args = memdup_user(argp, sizeof(*args));
1923 if (IS_ERR(args))
1924 return PTR_ERR(args);
ac8e9819 1925
ac8e9819
CM		 1926 inode = fdentry(file)->d_inode;
1927 ret = search_ioctl(inode, args);
1928 if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
1929 ret = -EFAULT;
1930 kfree(args);
1931 return ret;
1932}
1933
98d377a0 1934/*
ac8e9819
CM		 1935 * Search INODE_REFs to identify path name of 'dirid' directory
1936 * in a 'tree_id' tree. and sets path name to 'name'.
1937 */
98d377a0
TH		 1938static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
1939 u64 tree_id, u64 dirid, char *name)
1940{
1941 struct btrfs_root *root;
1942 struct btrfs_key key;
ac8e9819 1943 char *ptr;
98d377a0
TH		 1944 int ret = -1;
1945 int slot;
1946 int len;
1947 int total_len = 0;
1948 struct btrfs_inode_ref *iref;
1949 struct extent_buffer *l;
1950 struct btrfs_path *path;
1951
1952 if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
1953 name[0]='\0';
1954 return 0;
1955 }
1956
1957 path = btrfs_alloc_path();
1958 if (!path)
1959 return -ENOMEM;
1960
ac8e9819 1961 ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX];
98d377a0
TH		 1962
1963 key.objectid = tree_id;
1964 key.type = BTRFS_ROOT_ITEM_KEY;
1965 key.offset = (u64)-1;
1966 root = btrfs_read_fs_root_no_name(info, &key);
1967 if (IS_ERR(root)) {
1968 printk(KERN_ERR "could not find root %llu\n", tree_id);
8ad6fcab
CM		 1969 ret = -ENOENT;
1970 goto out;
98d377a0
TH		 1971 }
1972
1973 key.objectid = dirid;
1974 key.type = BTRFS_INODE_REF_KEY;
8ad6fcab 1975 key.offset = (u64)-1;
98d377a0
TH		 1976
1977 while(1) {
1978 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1979 if (ret < 0)
1980 goto out;
1981
1982 l = path->nodes[0];
1983 slot = path->slots[0];
8ad6fcab
CM		 1984 if (ret > 0 && slot > 0)
1985 slot--;
98d377a0
TH		 1986 btrfs_item_key_to_cpu(l, &key, slot);
1987
1988 if (ret > 0 && (key.objectid != dirid ||
ac8e9819
CM		 1989 key.type != BTRFS_INODE_REF_KEY)) {
1990 ret = -ENOENT;
98d377a0 1991 goto out;
ac8e9819 1992 }
98d377a0
TH		 1993
1994 iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
1995 len = btrfs_inode_ref_name_len(l, iref);
1996 ptr -= len + 1;
1997 total_len += len + 1;
ac8e9819 1998 if (ptr < name)
98d377a0
TH		 1999 goto out;
2000
2001 *(ptr + len) = '/';
2002 read_extent_buffer(l, ptr,(unsigned long)(iref + 1), len);
2003
2004 if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
2005 break;
2006
b3b4aa74 2007 btrfs_release_path(path);
98d377a0 2008 key.objectid = key.offset;
8ad6fcab 2009 key.offset = (u64)-1;
98d377a0 2010 dirid = key.objectid;
98d377a0 2011 }
ac8e9819 2012 if (ptr < name)
98d377a0 2013 goto out;
77906a50 2014 memmove(name, ptr, total_len);
98d377a0
TH		 2015 name[total_len]='\0';
2016 ret = 0;
2017out:
2018 btrfs_free_path(path);
ac8e9819
CM		 2019 return ret;
2020}
2021
2022static noinline int btrfs_ioctl_ino_lookup(struct file *file,
2023 void __user *argp)
2024{
2025 struct btrfs_ioctl_ino_lookup_args *args;
2026 struct inode *inode;
2027 int ret;
2028
2029 if (!capable(CAP_SYS_ADMIN))
2030 return -EPERM;
2031
2354d08f
JL		 2032 args = memdup_user(argp, sizeof(*args));
2033 if (IS_ERR(args))
2034 return PTR_ERR(args);
c2b96929 2035
ac8e9819
CM		 2036 inode = fdentry(file)->d_inode;
2037
1b53ac4d
CM		 2038 if (args->treeid == 0)
2039 args->treeid = BTRFS_I(inode)->root->root_key.objectid;
2040
ac8e9819
CM		 2041 ret = btrfs_search_path_in_tree(BTRFS_I(inode)->root->fs_info,
2042 args->treeid, args->objectid,
2043 args->name);
2044
2045 if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2046 ret = -EFAULT;
2047
2048 kfree(args);
98d377a0
TH		 2049 return ret;
2050}
2051
76dda93c
YZ		 2052static noinline int btrfs_ioctl_snap_destroy(struct file *file,
2053 void __user *arg)
2054{
2055 struct dentry *parent = fdentry(file);
2056 struct dentry *dentry;
2057 struct inode *dir = parent->d_inode;
2058 struct inode *inode;
2059 struct btrfs_root *root = BTRFS_I(dir)->root;
2060 struct btrfs_root *dest = NULL;
2061 struct btrfs_ioctl_vol_args *vol_args;
2062 struct btrfs_trans_handle *trans;
c58aaad2
MX		 2063 struct btrfs_block_rsv block_rsv;
2064 u64 qgroup_reserved;
76dda93c
YZ		 2065 int namelen;
2066 int ret;
2067 int err = 0;
2068
76dda93c
YZ		 2069 vol_args = memdup_user(arg, sizeof(*vol_args));
2070 if (IS_ERR(vol_args))
2071 return PTR_ERR(vol_args);
2072
2073 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2074 namelen = strlen(vol_args->name);
2075 if (strchr(vol_args->name, '/') ||
2076 strncmp(vol_args->name, "..", namelen) == 0) {
2077 err = -EINVAL;
2078 goto out;
2079 }
2080
a561be71 2081 err = mnt_want_write_file(file);
76dda93c
YZ		 2082 if (err)
2083 goto out;
2084
2085 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
2086 dentry = lookup_one_len(vol_args->name, parent, namelen);
2087 if (IS_ERR(dentry)) {
2088 err = PTR_ERR(dentry);
2089 goto out_unlock_dir;
2090 }
2091
2092 if (!dentry->d_inode) {
2093 err = -ENOENT;
2094 goto out_dput;
2095 }
2096
2097 inode = dentry->d_inode;
4260f7c7
SW		 2098 dest = BTRFS_I(inode)->root;
2099 if (!capable(CAP_SYS_ADMIN)){
2100 /*
2101 * Regular user. Only allow this with a special mount
2102 * option, when the user has write+exec access to the
2103 * subvol root, and when rmdir(2) would have been
2104 * allowed.
2105 *
2106 * Note that this is _not_ check that the subvol is
2107 * empty or doesn't contain data that we wouldn't
2108 * otherwise be able to delete.
2109 *
2110 * Users who want to delete empty subvols should try
2111 * rmdir(2).
2112 */
2113 err = -EPERM;
2114 if (!btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
2115 goto out_dput;
2116
2117 /*
2118 * Do not allow deletion if the parent dir is the same
2119 * as the dir to be deleted. That means the ioctl
2120 * must be called on the dentry referencing the root
2121 * of the subvol, not a random directory contained
2122 * within it.
2123 */
2124 err = -EINVAL;
2125 if (root == dest)
2126 goto out_dput;
2127
2128 err = inode_permission(inode, MAY_WRITE | MAY_EXEC);
2129 if (err)
2130 goto out_dput;
4260f7c7
SW		 2131 }
2132
5c39da5b
MX		 2133 /* check if subvolume may be deleted by a user */
2134 err = btrfs_may_delete(dir, dentry, 1);
2135 if (err)
2136 goto out_dput;
2137
33345d01 2138 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
76dda93c
YZ		 2139 err = -EINVAL;
2140 goto out_dput;
2141 }
2142
76dda93c
YZ		 2143 mutex_lock(&inode->i_mutex);
2144 err = d_invalidate(dentry);
2145 if (err)
2146 goto out_unlock;
2147
2148 down_write(&root->fs_info->subvol_sem);
2149
2150 err = may_destroy_subvol(dest);
2151 if (err)
2152 goto out_up_write;
2153
c58aaad2
MX		 2154 btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
2155 /*
2156 * One for dir inode, two for dir entries, two for root
2157 * ref/backref.
2158 */
2159 err = btrfs_subvolume_reserve_metadata(root, &block_rsv,
2160 5, &qgroup_reserved);
2161 if (err)
2162 goto out_up_write;
2163
a22285a6
YZ		 2164 trans = btrfs_start_transaction(root, 0);
2165 if (IS_ERR(trans)) {
2166 err = PTR_ERR(trans);
c58aaad2 2167 goto out_release;
a22285a6 2168 }
c58aaad2
MX		 2169 trans->block_rsv = &block_rsv;
2170 trans->bytes_reserved = block_rsv.size;
a22285a6 2171
76dda93c
YZ		 2172 ret = btrfs_unlink_subvol(trans, root, dir,
2173 dest->root_key.objectid,
2174 dentry->d_name.name,
2175 dentry->d_name.len);
79787eaa
JM		 2176 if (ret) {
2177 err = ret;
2178 btrfs_abort_transaction(trans, root, ret);
2179 goto out_end_trans;
2180 }
76dda93c
YZ		 2181
2182 btrfs_record_root_in_trans(trans, dest);
2183
2184 memset(&dest->root_item.drop_progress, 0,
2185 sizeof(dest->root_item.drop_progress));
2186 dest->root_item.drop_level = 0;
2187 btrfs_set_root_refs(&dest->root_item, 0);
2188
d68fc57b
YZ		 2189 if (!xchg(&dest->orphan_item_inserted, 1)) {
2190 ret = btrfs_insert_orphan_item(trans,
2191 root->fs_info->tree_root,
2192 dest->root_key.objectid);
79787eaa
JM		 2193 if (ret) {
2194 btrfs_abort_transaction(trans, root, ret);
2195 err = ret;
2196 goto out_end_trans;
2197 }
d68fc57b 2198 }
79787eaa 2199out_end_trans:
c58aaad2
MX		 2200 trans->block_rsv = NULL;
2201 trans->bytes_reserved = 0;
531cb13f 2202 ret = btrfs_end_transaction(trans, root);
79787eaa
JM		 2203 if (ret && !err)
2204 err = ret;
76dda93c 2205 inode->i_flags |= S_DEAD;
c58aaad2
MX		 2206out_release:
2207 btrfs_subvolume_release_metadata(root, &block_rsv, qgroup_reserved);
76dda93c
YZ		 2208out_up_write:
2209 up_write(&root->fs_info->subvol_sem);
2210out_unlock:
2211 mutex_unlock(&inode->i_mutex);
2212 if (!err) {
efefb143 2213 shrink_dcache_sb(root->fs_info->sb);
76dda93c
YZ		 2214 btrfs_invalidate_inodes(dest);
2215 d_delete(dentry);
fa6ac876
LB		 2216
2217 /* the last ref */
2218 if (dest->cache_inode) {
2219 iput(dest->cache_inode);
2220 dest->cache_inode = NULL;
2221 }
76dda93c
YZ		 2222 }
2223out_dput:
2224 dput(dentry);
2225out_unlock_dir:
2226 mutex_unlock(&dir->i_mutex);
2a79f17e 2227 mnt_drop_write_file(file);
76dda93c
YZ		 2228out:
2229 kfree(vol_args);
2230 return err;
2231}
2232
1e701a32 2233static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
f46b5a66
CH		 2234{
2235 struct inode *inode = fdentry(file)->d_inode;
2236 struct btrfs_root *root = BTRFS_I(inode)->root;
1e701a32 2237 struct btrfs_ioctl_defrag_range_args *range;
c146afad
YZ		 2238 int ret;
2239
25122d15
ID		 2240 ret = mnt_want_write_file(file);
2241 if (ret)
2242 return ret;
b83cc969 2243
5ac00add
SB		 2244 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
2245 1)) {
2246 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
25122d15 2247 mnt_drop_write_file(file);
2c0c9da0 2248 return -EINVAL;
5ac00add 2249 }
25122d15
ID		 2250
2251 if (btrfs_root_readonly(root)) {
2252 ret = -EROFS;
2253 goto out;
5ac00add 2254 }
f46b5a66
CH		 2255
2256 switch (inode->i_mode & S_IFMT) {
2257 case S_IFDIR:
e441d54d
CM		 2258 if (!capable(CAP_SYS_ADMIN)) {
2259 ret = -EPERM;
2260 goto out;
2261 }
de78b51a 2262 ret = btrfs_defrag_root(root);
8929ecfa
YZ		 2263 if (ret)
2264 goto out;
de78b51a 2265 ret = btrfs_defrag_root(root->fs_info->extent_root);
f46b5a66
CH		 2266 break;
2267 case S_IFREG:
e441d54d
CM		 2268 if (!(file->f_mode & FMODE_WRITE)) {
2269 ret = -EINVAL;
2270 goto out;
2271 }
1e701a32
CM		 2272
2273 range = kzalloc(sizeof(*range), GFP_KERNEL);
2274 if (!range) {
2275 ret = -ENOMEM;
2276 goto out;
2277 }
2278
2279 if (argp) {
2280 if (copy_from_user(range, argp,
2281 sizeof(*range))) {
2282 ret = -EFAULT;
2283 kfree(range);
683be16e 2284 goto out;
1e701a32
CM		 2285 }
2286 /* compression requires us to start the IO */
2287 if ((range->flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
2288 range->flags |= BTRFS_DEFRAG_RANGE_START_IO;
2289 range->extent_thresh = (u32)-1;
2290 }
2291 } else {
2292 /* the rest are all set to zero by kzalloc */
2293 range->len = (u64)-1;
2294 }
4cb5300b
CM		 2295 ret = btrfs_defrag_file(fdentry(file)->d_inode, file,
2296 range, 0, 0);
2297 if (ret > 0)
2298 ret = 0;
1e701a32 2299 kfree(range);
f46b5a66 2300 break;
8929ecfa
YZ		 2301 default:
2302 ret = -EINVAL;
f46b5a66 2303 }
e441d54d 2304out:
5ac00add 2305 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
25122d15 2306 mnt_drop_write_file(file);
e441d54d 2307 return ret;
f46b5a66
CH		 2308}
2309
b2950863 2310static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
f46b5a66
CH		 2311{
2312 struct btrfs_ioctl_vol_args *vol_args;
2313 int ret;
2314
e441d54d
CM		 2315 if (!capable(CAP_SYS_ADMIN))
2316 return -EPERM;
2317
5ac00add
SB		 2318 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
2319 1)) {
2320 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
2c0c9da0 2321 return -EINVAL;
c9e9f97b
ID		 2322 }
2323
5ac00add 2324 mutex_lock(&root->fs_info->volume_mutex);
dae7b665 2325 vol_args = memdup_user(arg, sizeof(*vol_args));
c9e9f97b
ID		 2326 if (IS_ERR(vol_args)) {
2327 ret = PTR_ERR(vol_args);
2328 goto out;
2329 }
f46b5a66 2330
5516e595 2331 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
f46b5a66
CH		 2332 ret = btrfs_init_new_device(root, vol_args->name);
2333
f46b5a66 2334 kfree(vol_args);
c9e9f97b
ID		 2335out:
2336 mutex_unlock(&root->fs_info->volume_mutex);
5ac00add 2337 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
f46b5a66
CH		 2338 return ret;
2339}
2340
da24927b 2341static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
f46b5a66 2342{
da24927b 2343 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
f46b5a66
CH		 2344 struct btrfs_ioctl_vol_args *vol_args;
2345 int ret;
2346
e441d54d
CM		 2347 if (!capable(CAP_SYS_ADMIN))
2348 return -EPERM;
2349
da24927b
MX		 2350 ret = mnt_want_write_file(file);
2351 if (ret)
2352 return ret;
c146afad 2353
5ac00add
SB		 2354 if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
2355 1)) {
2356 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
da24927b 2357 mnt_drop_write_file(file);
2c0c9da0 2358 return -EINVAL;
c9e9f97b
ID		 2359 }
2360
5ac00add 2361 mutex_lock(&root->fs_info->volume_mutex);
dae7b665 2362 vol_args = memdup_user(arg, sizeof(*vol_args));
c9e9f97b
ID		 2363 if (IS_ERR(vol_args)) {
2364 ret = PTR_ERR(vol_args);
2365 goto out;
2366 }
f46b5a66 2367
5516e595 2368 vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
f46b5a66
CH		 2369 ret = btrfs_rm_device(root, vol_args->name);
2370
f46b5a66 2371 kfree(vol_args);
c9e9f97b
ID		 2372out:
2373 mutex_unlock(&root->fs_info->volume_mutex);
5ac00add 2374 atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
4ac20c70 2375 mnt_drop_write_file(file);
f46b5a66
CH		 2376 return ret;
2377}
2378
475f6387
JS		 2379static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
2380{
027ed2f0 2381 struct btrfs_ioctl_fs_info_args *fi_args;
475f6387
JS		 2382 struct btrfs_device *device;
2383 struct btrfs_device *next;
2384 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
027ed2f0 2385 int ret = 0;
475f6387
JS		 2386
2387 if (!capable(CAP_SYS_ADMIN))
2388 return -EPERM;
2389
027ed2f0
LZ		 2390 fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
2391 if (!fi_args)
2392 return -ENOMEM;
2393
2394 fi_args->num_devices = fs_devices->num_devices;
2395 memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
475f6387
JS		 2396
2397 mutex_lock(&fs_devices->device_list_mutex);
2398 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
027ed2f0
LZ		 2399 if (device->devid > fi_args->max_id)
2400 fi_args->max_id = device->devid;
475f6387
JS		 2401 }
2402 mutex_unlock(&fs_devices->device_list_mutex);
2403
027ed2f0
LZ		 2404 if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
2405 ret = -EFAULT;
475f6387 2406
027ed2f0
LZ		 2407 kfree(fi_args);
2408 return ret;
475f6387
JS		 2409}
2410
2411static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
2412{
2413 struct btrfs_ioctl_dev_info_args *di_args;
2414 struct btrfs_device *dev;
2415 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
2416 int ret = 0;
2417 char *s_uuid = NULL;
2418 char empty_uuid[BTRFS_UUID_SIZE] = {0};
2419
2420 if (!capable(CAP_SYS_ADMIN))
2421 return -EPERM;
2422
2423 di_args = memdup_user(arg, sizeof(*di_args));
2424 if (IS_ERR(di_args))
2425 return PTR_ERR(di_args);
2426
2427 if (memcmp(empty_uuid, di_args->uuid, BTRFS_UUID_SIZE) != 0)
2428 s_uuid = di_args->uuid;
2429
2430 mutex_lock(&fs_devices->device_list_mutex);
aa1b8cd4 2431 dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL);
475f6387
JS		 2432 mutex_unlock(&fs_devices->device_list_mutex);
2433
2434 if (!dev) {
2435 ret = -ENODEV;
2436 goto out;
2437 }
2438
2439 di_args->devid = dev->devid;
2440 di_args->bytes_used = dev->bytes_used;
2441 di_args->total_bytes = dev->total_bytes;
2442 memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
a27202fb 2443 if (dev->name) {
606686ee
JB		 2444 struct rcu_string *name;
2445
2446 rcu_read_lock();
2447 name = rcu_dereference(dev->name);
2448 strncpy(di_args->path, name->str, sizeof(di_args->path));
2449 rcu_read_unlock();
a27202fb
JM		 2450 di_args->path[sizeof(di_args->path) - 1] = 0;
2451 } else {
99ba55ad 2452 di_args->path[0] = '\0';
a27202fb 2453 }
475f6387
JS		 2454
2455out:
2456 if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
2457 ret = -EFAULT;
2458
2459 kfree(di_args);
2460 return ret;
2461}
2462
76dda93c
YZ		 2463static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
2464 u64 off, u64 olen, u64 destoff)
f46b5a66
CH		 2465{
2466 struct inode *inode = fdentry(file)->d_inode;
2467 struct btrfs_root *root = BTRFS_I(inode)->root;
2903ff01 2468 struct fd src_file;
f46b5a66
CH		 2469 struct inode *src;
2470 struct btrfs_trans_handle *trans;
f46b5a66 2471 struct btrfs_path *path;
f46b5a66 2472 struct extent_buffer *leaf;
ae01a0ab
YZ		 2473 char *buf;
2474 struct btrfs_key key;
f46b5a66
CH		 2475 u32 nritems;
2476 int slot;
ae01a0ab 2477 int ret;
c5c9cd4d
SW		 2478 u64 len = olen;
2479 u64 bs = root->fs_info->sb->s_blocksize;
d20f7043 2480
c5c9cd4d
SW		 2481 /*
2482 * TODO:
2483 * - split compressed inline extents. annoying: we need to
2484 * decompress into destination's address_space (the file offset
2485 * may change, so source mapping won't do), then recompress (or
2486 * otherwise reinsert) a subrange.
2487 * - allow ranges within the same file to be cloned (provided
2488 * they don't overlap)?
2489 */
2490
e441d54d 2491 /* the destination must be opened for writing */
2ebc3464 2492 if (!(file->f_mode & FMODE_WRITE) || (file->f_flags & O_APPEND))
e441d54d
CM		 2493 return -EINVAL;
2494
b83cc969
LZ		 2495 if (btrfs_root_readonly(root))
2496 return -EROFS;
2497
a561be71 2498 ret = mnt_want_write_file(file);
c146afad
YZ		 2499 if (ret)
2500 return ret;
2501
2903ff01
AV		 2502 src_file = fdget(srcfd);
2503 if (!src_file.file) {
ab67b7c1
YZ		 2504 ret = -EBADF;
2505 goto out_drop_write;
2506 }
5dc64164 2507
362a20c5 2508 ret = -EXDEV;
2903ff01 2509 if (src_file.file->f_path.mnt != file->f_path.mnt)
362a20c5
DS		 2510 goto out_fput;
2511
2903ff01 2512 src = src_file.file->f_dentry->d_inode;
f46b5a66 2513
c5c9cd4d
SW		 2514 ret = -EINVAL;
2515 if (src == inode)
2516 goto out_fput;
2517
5dc64164 2518 /* the src must be open for reading */
2903ff01 2519 if (!(src_file.file->f_mode & FMODE_READ))
5dc64164
DR		 2520 goto out_fput;
2521
0e7b824c
LZ		 2522 /* don't make the dst file partly checksummed */
2523 if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) !=
2524 (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
2525 goto out_fput;
2526
ae01a0ab
YZ		 2527 ret = -EISDIR;
2528 if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
2529 goto out_fput;
2530
f46b5a66 2531 ret = -EXDEV;
362a20c5 2532 if (src->i_sb != inode->i_sb)
ae01a0ab
YZ		 2533 goto out_fput;
2534
2535 ret = -ENOMEM;
2536 buf = vmalloc(btrfs_level_size(root, 0));
2537 if (!buf)
2538 goto out_fput;
2539
2540 path = btrfs_alloc_path();
2541 if (!path) {
2542 vfree(buf);
f46b5a66 2543 goto out_fput;
ae01a0ab
YZ		 2544 }
2545 path->reada = 2;
f46b5a66
CH		 2546
2547 if (inode < src) {
fccdae43
SW		 2548 mutex_lock_nested(&inode->i_mutex, I_MUTEX_PARENT);
2549 mutex_lock_nested(&src->i_mutex, I_MUTEX_CHILD);
f46b5a66 2550 } else {
fccdae43
SW		 2551 mutex_lock_nested(&src->i_mutex, I_MUTEX_PARENT);
2552 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
f46b5a66
CH		 2553 }
2554
c5c9cd4d
SW		 2555 /* determine range to clone */
2556 ret = -EINVAL;
2ebc3464 2557 if (off + len > src->i_size || off + len < off)
f46b5a66 2558 goto out_unlock;
c5c9cd4d
SW		 2559 if (len == 0)
2560 olen = len = src->i_size - off;
2561 /* if we extend to eof, continue to block boundary */
2562 if (off + len == src->i_size)
2a6b8dae 2563 len = ALIGN(src->i_size, bs) - off;
c5c9cd4d
SW		 2564
2565 /* verify the end result is block aligned */
2a6b8dae
LZ		 2566 if (!IS_ALIGNED(off, bs) || !IS_ALIGNED(off + len, bs) ||
2567 !IS_ALIGNED(destoff, bs))
c5c9cd4d
SW		 2568 goto out_unlock;
2569
d525e8ab
LZ		 2570 if (destoff > inode->i_size) {
2571 ret = btrfs_cont_expand(inode, inode->i_size, destoff);
2572 if (ret)
2573 goto out_unlock;
2574 }
2575
71ef0786
LZ		 2576 /* truncate page cache pages from target inode range */
2577 truncate_inode_pages_range(&inode->i_data, destoff,
2578 PAGE_CACHE_ALIGN(destoff + len) - 1);
2579
f46b5a66
CH		 2580 /* do any pending delalloc/csum calc on src, one way or
2581 another, and lock file content */
2582 while (1) {
31840ae1 2583 struct btrfs_ordered_extent *ordered;
aa42ffd9
LB		 2584 lock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
2585 ordered = btrfs_lookup_first_ordered_extent(src, off + len - 1);
9a019196 2586 if (!ordered &&
aa42ffd9
LB		 2587 !test_range_bit(&BTRFS_I(src)->io_tree, off, off + len - 1,
2588 EXTENT_DELALLOC, 0, NULL))
f46b5a66 2589 break;
aa42ffd9 2590 unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
ae01a0ab
YZ		 2591 if (ordered)
2592 btrfs_put_ordered_extent(ordered);
9a019196 2593 btrfs_wait_ordered_range(src, off, len);
f46b5a66
CH		 2594 }
2595
c5c9cd4d 2596 /* clone data */
33345d01 2597 key.objectid = btrfs_ino(src);
ae01a0ab
YZ		 2598 key.type = BTRFS_EXTENT_DATA_KEY;
2599 key.offset = 0;
f46b5a66
CH		 2600
2601 while (1) {
2602 /*
2603 * note the key will change type as we walk through the
2604 * tree.
2605 */
362a20c5
DS		 2606 ret = btrfs_search_slot(NULL, BTRFS_I(src)->root, &key, path,
2607 0, 0);
f46b5a66
CH		 2608 if (ret < 0)
2609 goto out;
2610
ae01a0ab
YZ		 2611 nritems = btrfs_header_nritems(path->nodes[0]);
2612 if (path->slots[0] >= nritems) {
362a20c5 2613 ret = btrfs_next_leaf(BTRFS_I(src)->root, path);
f46b5a66
CH		 2614 if (ret < 0)
2615 goto out;
2616 if (ret > 0)
2617 break;
ae01a0ab 2618 nritems = btrfs_header_nritems(path->nodes[0]);
f46b5a66
CH		 2619 }
2620 leaf = path->nodes[0];
2621 slot = path->slots[0];
f46b5a66 2622
ae01a0ab 2623 btrfs_item_key_to_cpu(leaf, &key, slot);
d20f7043 2624 if (btrfs_key_type(&key) > BTRFS_EXTENT_DATA_KEY ||
33345d01 2625 key.objectid != btrfs_ino(src))
f46b5a66
CH		 2626 break;
2627
c5c9cd4d
SW		 2628 if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
2629 struct btrfs_file_extent_item *extent;
2630 int type;
31840ae1
ZY		 2631 u32 size;
2632 struct btrfs_key new_key;
c5c9cd4d
SW		 2633 u64 disko = 0, diskl = 0;
2634 u64 datao = 0, datal = 0;
2635 u8 comp;
b5384d48 2636 u64 endoff;
31840ae1
ZY		 2637
2638 size = btrfs_item_size_nr(leaf, slot);
2639 read_extent_buffer(leaf, buf,
2640 btrfs_item_ptr_offset(leaf, slot),
2641 size);
c5c9cd4d
SW		 2642
2643 extent = btrfs_item_ptr(leaf, slot,
2644 struct btrfs_file_extent_item);
2645 comp = btrfs_file_extent_compression(leaf, extent);
2646 type = btrfs_file_extent_type(leaf, extent);
c8a894d7
CM		 2647 if (type == BTRFS_FILE_EXTENT_REG ||
2648 type == BTRFS_FILE_EXTENT_PREALLOC) {
d397712b
CM		 2649 disko = btrfs_file_extent_disk_bytenr(leaf,
2650 extent);
2651 diskl = btrfs_file_extent_disk_num_bytes(leaf,
2652 extent);
c5c9cd4d 2653 datao = btrfs_file_extent_offset(leaf, extent);
d397712b
CM		 2654 datal = btrfs_file_extent_num_bytes(leaf,
2655 extent);
c5c9cd4d
SW		 2656 } else if (type == BTRFS_FILE_EXTENT_INLINE) {
2657 /* take upper bound, may be compressed */
2658 datal = btrfs_file_extent_ram_bytes(leaf,
2659 extent);
2660 }
b3b4aa74 2661 btrfs_release_path(path);
31840ae1 2662
050006a7 2663 if (key.offset + datal <= off ||
aa42ffd9 2664 key.offset >= off + len - 1)
c5c9cd4d
SW		 2665 goto next;
2666
31840ae1 2667 memcpy(&new_key, &key, sizeof(new_key));
33345d01 2668 new_key.objectid = btrfs_ino(inode);
4d728ec7
LZ		 2669 if (off <= key.offset)
2670 new_key.offset = key.offset + destoff - off;
2671 else
2672 new_key.offset = destoff;
31840ae1 2673
b6f3409b
SW		 2674 /*
2675 * 1 - adjusting old extent (we may have to split it)
2676 * 1 - add new extent
2677 * 1 - inode update
2678 */
2679 trans = btrfs_start_transaction(root, 3);
a22285a6
YZ		 2680 if (IS_ERR(trans)) {
2681 ret = PTR_ERR(trans);
2682 goto out;
2683 }
2684
c8a894d7
CM		 2685 if (type == BTRFS_FILE_EXTENT_REG ||
2686 type == BTRFS_FILE_EXTENT_PREALLOC) {
d72c0842
LZ		 2687 /*
2688 * a | --- range to clone ---| b
2689 * | ------------- extent ------------- |
2690 */
2691
2692 /* substract range b */
2693 if (key.offset + datal > off + len)
2694 datal = off + len - key.offset;
2695
2696 /* substract range a */
a22285a6
YZ		 2697 if (off > key.offset) {
2698 datao += off - key.offset;
2699 datal -= off - key.offset;
2700 }
2701
5dc562c5 2702 ret = btrfs_drop_extents(trans, root, inode,
a22285a6
YZ		 2703 new_key.offset,
2704 new_key.offset + datal,
2671485d 2705 1);
79787eaa
JM		 2706 if (ret) {
2707 btrfs_abort_transaction(trans, root,
2708 ret);
2709 btrfs_end_transaction(trans, root);
2710 goto out;
2711 }
a22285a6 2712
c5c9cd4d
SW		 2713 ret = btrfs_insert_empty_item(trans, root, path,
2714 &new_key, size);
79787eaa
JM		 2715 if (ret) {
2716 btrfs_abort_transaction(trans, root,
2717 ret);
2718 btrfs_end_transaction(trans, root);
2719 goto out;
2720 }
c5c9cd4d
SW		 2721
2722 leaf = path->nodes[0];
2723 slot = path->slots[0];
2724 write_extent_buffer(leaf, buf,
31840ae1
ZY		 2725 btrfs_item_ptr_offset(leaf, slot),
2726 size);
ae01a0ab 2727
c5c9cd4d 2728 extent = btrfs_item_ptr(leaf, slot,
f46b5a66 2729 struct btrfs_file_extent_item);
c5c9cd4d 2730
c5c9cd4d
SW		 2731 /* disko == 0 means it's a hole */
2732 if (!disko)
2733 datao = 0;
c5c9cd4d
SW		 2734
2735 btrfs_set_file_extent_offset(leaf, extent,
2736 datao);
2737 btrfs_set_file_extent_num_bytes(leaf, extent,
2738 datal);
2739 if (disko) {
2740 inode_add_bytes(inode, datal);
ae01a0ab 2741 ret = btrfs_inc_extent_ref(trans, root,
5d4f98a2
YZ		 2742 disko, diskl, 0,
2743 root->root_key.objectid,
33345d01 2744 btrfs_ino(inode),
66d7e7f0
AJ		 2745 new_key.offset - datao,
2746 0);
79787eaa
JM		 2747 if (ret) {
2748 btrfs_abort_transaction(trans,
2749 root,
2750 ret);
2751 btrfs_end_transaction(trans,
2752 root);
2753 goto out;
2754
2755 }
f46b5a66 2756 }
c5c9cd4d
SW		 2757 } else if (type == BTRFS_FILE_EXTENT_INLINE) {
2758 u64 skip = 0;
2759 u64 trim = 0;
2760 if (off > key.offset) {
2761 skip = off - key.offset;
2762 new_key.offset += skip;
2763 }
d397712b 2764
aa42ffd9
LB		 2765 if (key.offset + datal > off + len)
2766 trim = key.offset + datal - (off + len);
d397712b 2767
c5c9cd4d 2768 if (comp && (skip || trim)) {
c5c9cd4d 2769 ret = -EINVAL;
a22285a6 2770 btrfs_end_transaction(trans, root);
c5c9cd4d
SW		 2771 goto out;
2772 }
2773 size -= skip + trim;
2774 datal -= skip + trim;
a22285a6 2775
5dc562c5 2776 ret = btrfs_drop_extents(trans, root, inode,
a22285a6
YZ		 2777 new_key.offset,
2778 new_key.offset + datal,
2671485d 2779 1);
79787eaa
JM		 2780 if (ret) {
2781 btrfs_abort_transaction(trans, root,
2782 ret);
2783 btrfs_end_transaction(trans, root);
2784 goto out;
2785 }
a22285a6 2786
c5c9cd4d
SW		 2787 ret = btrfs_insert_empty_item(trans, root, path,
2788 &new_key, size);
79787eaa
JM		 2789 if (ret) {
2790 btrfs_abort_transaction(trans, root,
2791 ret);
2792 btrfs_end_transaction(trans, root);
2793 goto out;
2794 }
c5c9cd4d
SW		 2795
2796 if (skip) {
d397712b
CM		 2797 u32 start =
2798 btrfs_file_extent_calc_inline_size(0);
c5c9cd4d
SW		 2799 memmove(buf+start, buf+start+skip,
2800 datal);
2801 }
2802
2803 leaf = path->nodes[0];
2804 slot = path->slots[0];
2805 write_extent_buffer(leaf, buf,
2806 btrfs_item_ptr_offset(leaf, slot),
2807 size);
2808 inode_add_bytes(inode, datal);
f46b5a66 2809 }
c5c9cd4d
SW		 2810
2811 btrfs_mark_buffer_dirty(leaf);
b3b4aa74 2812 btrfs_release_path(path);
c5c9cd4d 2813
0c4d2d95 2814 inode_inc_iversion(inode);
a22285a6 2815 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
b5384d48
SW		 2816
2817 /*
2818 * we round up to the block size at eof when
2819 * determining which extents to clone above,
2820 * but shouldn't round up the file size
2821 */
2822 endoff = new_key.offset + datal;
5f3888ff
LZ		 2823 if (endoff > destoff+olen)
2824 endoff = destoff+olen;
b5384d48
SW		 2825 if (endoff > inode->i_size)
2826 btrfs_i_size_write(inode, endoff);
2827
a22285a6 2828 ret = btrfs_update_inode(trans, root, inode);
79787eaa
JM		 2829 if (ret) {
2830 btrfs_abort_transaction(trans, root, ret);
2831 btrfs_end_transaction(trans, root);
2832 goto out;
2833 }
2834 ret = btrfs_end_transaction(trans, root);
a22285a6 2835 }
d397712b 2836next:
b3b4aa74 2837 btrfs_release_path(path);
f46b5a66 2838 key.offset++;
f46b5a66 2839 }
f46b5a66
CH		 2840 ret = 0;
2841out:
b3b4aa74 2842 btrfs_release_path(path);
aa42ffd9 2843 unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
f46b5a66
CH		 2844out_unlock:
2845 mutex_unlock(&src->i_mutex);
2846 mutex_unlock(&inode->i_mutex);
ae01a0ab
YZ		 2847 vfree(buf);
2848 btrfs_free_path(path);
f46b5a66 2849out_fput:
2903ff01 2850 fdput(src_file);
ab67b7c1 2851out_drop_write:
2a79f17e 2852 mnt_drop_write_file(file);
f46b5a66
CH		 2853 return ret;
2854}
2855
7a865e8a 2856static long btrfs_ioctl_clone_range(struct file *file, void __user *argp)
c5c9cd4d
SW		 2857{
2858 struct btrfs_ioctl_clone_range_args args;
2859
7a865e8a 2860 if (copy_from_user(&args, argp, sizeof(args)))
c5c9cd4d
SW		 2861 return -EFAULT;
2862 return btrfs_ioctl_clone(file, args.src_fd, args.src_offset,
2863 args.src_length, args.dest_offset);
2864}
2865
f46b5a66
CH		 2866/*
2867 * there are many ways the trans_start and trans_end ioctls can lead
2868 * to deadlocks. They should only be used by applications that
2869 * basically own the machine, and have a very in depth understanding
2870 * of all the possible deadlocks and enospc problems.
2871 */
b2950863 2872static long btrfs_ioctl_trans_start(struct file *file)
f46b5a66
CH		 2873{
2874 struct inode *inode = fdentry(file)->d_inode;
2875 struct btrfs_root *root = BTRFS_I(inode)->root;
2876 struct btrfs_trans_handle *trans;
1ab86aed 2877 int ret;
f46b5a66 2878
1ab86aed 2879 ret = -EPERM;
df5b5520 2880 if (!capable(CAP_SYS_ADMIN))
1ab86aed 2881 goto out;
df5b5520 2882
1ab86aed
SW		 2883 ret = -EINPROGRESS;
2884 if (file->private_data)
f46b5a66 2885 goto out;
9ca9ee09 2886
b83cc969
LZ		 2887 ret = -EROFS;
2888 if (btrfs_root_readonly(root))
2889 goto out;
2890
a561be71 2891 ret = mnt_want_write_file(file);
c146afad
YZ		 2892 if (ret)
2893 goto out;
2894
a4abeea4 2895 atomic_inc(&root->fs_info->open_ioctl_trans);
9ca9ee09 2896
1ab86aed 2897 ret = -ENOMEM;
7a7eaa40 2898 trans = btrfs_start_ioctl_transaction(root);
abd30bb0 2899 if (IS_ERR(trans))
1ab86aed
SW		 2900 goto out_drop;
2901
2902 file->private_data = trans;
2903 return 0;
2904
2905out_drop:
a4abeea4 2906 atomic_dec(&root->fs_info->open_ioctl_trans);
2a79f17e 2907 mnt_drop_write_file(file);
f46b5a66 2908out:
f46b5a66
CH		 2909 return ret;
2910}
2911
6ef5ed0d
JB		 2912static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
2913{
2914 struct inode *inode = fdentry(file)->d_inode;
2915 struct btrfs_root *root = BTRFS_I(inode)->root;
2916 struct btrfs_root *new_root;
2917 struct btrfs_dir_item *di;
2918 struct btrfs_trans_handle *trans;
2919 struct btrfs_path *path;
2920 struct btrfs_key location;
2921 struct btrfs_disk_key disk_key;
6ef5ed0d
JB		 2922 u64 objectid = 0;
2923 u64 dir_id;
3c04ce01 2924 int ret;
6ef5ed0d
JB		 2925
2926 if (!capable(CAP_SYS_ADMIN))
2927 return -EPERM;
2928
3c04ce01
MX		 2929 ret = mnt_want_write_file(file);
2930 if (ret)
2931 return ret;
2932
2933 if (copy_from_user(&objectid, argp, sizeof(objectid))) {
2934 ret = -EFAULT;
2935 goto out;
2936 }
6ef5ed0d
JB		 2937
2938 if (!objectid)
2939 objectid = root->root_key.objectid;
2940
2941 location.objectid = objectid;
2942 location.type = BTRFS_ROOT_ITEM_KEY;
2943 location.offset = (u64)-1;
2944
2945 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
3c04ce01
MX		 2946 if (IS_ERR(new_root)) {
2947 ret = PTR_ERR(new_root);
2948 goto out;
2949 }
6ef5ed0d 2950
3c04ce01
MX		 2951 if (btrfs_root_refs(&new_root->root_item) == 0) {
2952 ret = -ENOENT;
2953 goto out;
2954 }
6ef5ed0d
JB		 2955
2956 path = btrfs_alloc_path();
3c04ce01
MX		 2957 if (!path) {
2958 ret = -ENOMEM;
2959 goto out;
2960 }
6ef5ed0d
JB		 2961 path->leave_spinning = 1;
2962
2963 trans = btrfs_start_transaction(root, 1);
98d5dc13 2964 if (IS_ERR(trans)) {
6ef5ed0d 2965 btrfs_free_path(path);
3c04ce01
MX		 2966 ret = PTR_ERR(trans);
2967 goto out;
6ef5ed0d
JB		 2968 }
2969
6c41761f 2970 dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
6ef5ed0d
JB		 2971 di = btrfs_lookup_dir_item(trans, root->fs_info->tree_root, path,
2972 dir_id, "default", 7, 1);
cf1e99a4 2973 if (IS_ERR_OR_NULL(di)) {
6ef5ed0d
JB		 2974 btrfs_free_path(path);
2975 btrfs_end_transaction(trans, root);
2976 printk(KERN_ERR "Umm, you don't have the default dir item, "
2977 "this isn't going to work\n");
3c04ce01
MX		 2978 ret = -ENOENT;
2979 goto out;
6ef5ed0d
JB		 2980 }
2981
2982 btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
2983 btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
2984 btrfs_mark_buffer_dirty(path->nodes[0]);
2985 btrfs_free_path(path);
2986
2b0ce2c2 2987 btrfs_set_fs_incompat(root->fs_info, DEFAULT_SUBVOL);
6ef5ed0d 2988 btrfs_end_transaction(trans, root);
3c04ce01
MX		 2989out:
2990 mnt_drop_write_file(file);
2991 return ret;
6ef5ed0d
JB		 2992}
2993
5af3e8cc
SB		 2994void btrfs_get_block_group_info(struct list_head *groups_list,
2995 struct btrfs_ioctl_space_info *space)
bf5fc093
JB		 2996{
2997 struct btrfs_block_group_cache *block_group;
2998
2999 space->total_bytes = 0;
3000 space->used_bytes = 0;
3001 space->flags = 0;
3002 list_for_each_entry(block_group, groups_list, list) {
3003 space->flags = block_group->flags;
3004 space->total_bytes += block_group->key.offset;
3005 space->used_bytes +=
3006 btrfs_block_group_used(&block_group->item);
3007 }
3008}
3009
1406e432
JB		 3010long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
3011{
3012 struct btrfs_ioctl_space_args space_args;
3013 struct btrfs_ioctl_space_info space;
3014 struct btrfs_ioctl_space_info *dest;
7fde62bf 3015 struct btrfs_ioctl_space_info *dest_orig;
13f2696f 3016 struct btrfs_ioctl_space_info __user *user_dest;
1406e432 3017 struct btrfs_space_info *info;
bf5fc093
JB		 3018 u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
3019 BTRFS_BLOCK_GROUP_SYSTEM,
3020 BTRFS_BLOCK_GROUP_METADATA,
3021 BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
3022 int num_types = 4;
7fde62bf 3023 int alloc_size;
1406e432 3024 int ret = 0;
51788b1b 3025 u64 slot_count = 0;
bf5fc093 3026 int i, c;
1406e432
JB		 3027
3028 if (copy_from_user(&space_args,
3029 (struct btrfs_ioctl_space_args __user *)arg,
3030 sizeof(space_args)))
3031 return -EFAULT;
3032
bf5fc093
JB		 3033 for (i = 0; i < num_types; i++) {
3034 struct btrfs_space_info *tmp;
3035
3036 info = NULL;
3037 rcu_read_lock();
3038 list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
3039 list) {
3040 if (tmp->flags == types[i]) {
3041 info = tmp;
3042 break;
3043 }
3044 }
3045 rcu_read_unlock();
3046
3047 if (!info)
3048 continue;
3049
3050 down_read(&info->groups_sem);
3051 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3052 if (!list_empty(&info->block_groups[c]))
3053 slot_count++;
3054 }
3055 up_read(&info->groups_sem);
3056 }
7fde62bf
CM		 3057
3058 /* space_slots == 0 means they are asking for a count */
3059 if (space_args.space_slots == 0) {
3060 space_args.total_spaces = slot_count;
3061 goto out;
3062 }
bf5fc093 3063
51788b1b 3064 slot_count = min_t(u64, space_args.space_slots, slot_count);
bf5fc093 3065
7fde62bf 3066 alloc_size = sizeof(*dest) * slot_count;
bf5fc093 3067
7fde62bf
CM		 3068 /* we generally have at most 6 or so space infos, one for each raid
3069 * level. So, a whole page should be more than enough for everyone
3070 */
3071 if (alloc_size > PAGE_CACHE_SIZE)
3072 return -ENOMEM;
3073
1406e432 3074 space_args.total_spaces = 0;
7fde62bf
CM		 3075 dest = kmalloc(alloc_size, GFP_NOFS);
3076 if (!dest)
3077 return -ENOMEM;
3078 dest_orig = dest;
1406e432 3079
7fde62bf 3080 /* now we have a buffer to copy into */
bf5fc093
JB		 3081 for (i = 0; i < num_types; i++) {
3082 struct btrfs_space_info *tmp;
3083
51788b1b
DR		 3084 if (!slot_count)
3085 break;
3086
bf5fc093
JB		 3087 info = NULL;
3088 rcu_read_lock();
3089 list_for_each_entry_rcu(tmp, &root->fs_info->space_info,
3090 list) {
3091 if (tmp->flags == types[i]) {
3092 info = tmp;
3093 break;
3094 }
3095 }
3096 rcu_read_unlock();
7fde62bf 3097
bf5fc093
JB		 3098 if (!info)
3099 continue;
3100 down_read(&info->groups_sem);
3101 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3102 if (!list_empty(&info->block_groups[c])) {
5af3e8cc
SB		 3103 btrfs_get_block_group_info(
3104 &info->block_groups[c], &space);
bf5fc093
JB		 3105 memcpy(dest, &space, sizeof(space));
3106 dest++;
3107 space_args.total_spaces++;
51788b1b 3108 slot_count--;
bf5fc093 3109 }
51788b1b
DR		 3110 if (!slot_count)
3111 break;
bf5fc093
JB		 3112 }
3113 up_read(&info->groups_sem);
1406e432 3114 }
1406e432 3115
2eec6c81 3116 user_dest = (struct btrfs_ioctl_space_info __user *)
7fde62bf
CM		 3117 (arg + sizeof(struct btrfs_ioctl_space_args));
3118
3119 if (copy_to_user(user_dest, dest_orig, alloc_size))
3120 ret = -EFAULT;
3121
3122 kfree(dest_orig);
3123out:
3124 if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
1406e432
JB		 3125 ret = -EFAULT;
3126
3127 return ret;
3128}
3129
f46b5a66
CH		 3130/*
3131 * there are many ways the trans_start and trans_end ioctls can lead
3132 * to deadlocks. They should only be used by applications that
3133 * basically own the machine, and have a very in depth understanding
3134 * of all the possible deadlocks and enospc problems.
3135 */
3136long btrfs_ioctl_trans_end(struct file *file)
3137{
3138 struct inode *inode = fdentry(file)->d_inode;
3139 struct btrfs_root *root = BTRFS_I(inode)->root;
3140 struct btrfs_trans_handle *trans;
f46b5a66 3141
f46b5a66 3142 trans = file->private_data;
1ab86aed
SW		 3143 if (!trans)
3144 return -EINVAL;
b214107e 3145 file->private_data = NULL;
9ca9ee09 3146
1ab86aed
SW		 3147 btrfs_end_transaction(trans, root);
3148
a4abeea4 3149 atomic_dec(&root->fs_info->open_ioctl_trans);
9ca9ee09 3150
2a79f17e 3151 mnt_drop_write_file(file);
1ab86aed 3152 return 0;
f46b5a66
CH		 3153}
3154
9a8c28be
MX		 3155static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
3156 void __user *argp)
46204592 3157{
46204592
SW		 3158 struct btrfs_trans_handle *trans;
3159 u64 transid;
db5b493a 3160 int ret;
46204592 3161
d4edf39b 3162 trans = btrfs_attach_transaction_barrier(root);
ff7c1d33
MX		 3163 if (IS_ERR(trans)) {
3164 if (PTR_ERR(trans) != -ENOENT)
3165 return PTR_ERR(trans);
3166
3167 /* No running transaction, don't bother */
3168 transid = root->fs_info->last_trans_committed;
3169 goto out;
3170 }
46204592 3171 transid = trans->transid;
db5b493a 3172 ret = btrfs_commit_transaction_async(trans, root, 0);
8b2b2d3c
TI		 3173 if (ret) {
3174 btrfs_end_transaction(trans, root);
db5b493a 3175 return ret;
8b2b2d3c 3176 }
ff7c1d33 3177out:
46204592
SW		 3178 if (argp)
3179 if (copy_to_user(argp, &transid, sizeof(transid)))
3180 return -EFAULT;
3181 return 0;
3182}
3183
9a8c28be
MX		 3184static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root,
3185 void __user *argp)
46204592 3186{
46204592
SW		 3187 u64 transid;
3188
3189 if (argp) {
3190 if (copy_from_user(&transid, argp, sizeof(transid)))
3191 return -EFAULT;
3192 } else {
3193 transid = 0; /* current trans */
3194 }
3195 return btrfs_wait_for_commit(root, transid);
3196}
3197
b8e95489 3198static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
475f6387 3199{
b8e95489 3200 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
475f6387 3201 struct btrfs_ioctl_scrub_args *sa;
b8e95489 3202 int ret;
475f6387
JS		 3203
3204 if (!capable(CAP_SYS_ADMIN))
3205 return -EPERM;
3206
3207 sa = memdup_user(arg, sizeof(*sa));
3208 if (IS_ERR(sa))
3209 return PTR_ERR(sa);
3210
b8e95489
MX		 3211 if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
3212 ret = mnt_want_write_file(file);
3213 if (ret)
3214 goto out;
3215 }
3216
aa1b8cd4 3217 ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end,
63a212ab
SB		 3218 &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
3219 0);
475f6387
JS		 3220
3221 if (copy_to_user(arg, sa, sizeof(*sa)))
3222 ret = -EFAULT;
3223
b8e95489
MX		 3224 if (!(sa->flags & BTRFS_SCRUB_READONLY))
3225 mnt_drop_write_file(file);
3226out:
475f6387
JS		 3227 kfree(sa);
3228 return ret;
3229}
3230
3231static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
3232{
3233 if (!capable(CAP_SYS_ADMIN))
3234 return -EPERM;
3235
aa1b8cd4 3236 return btrfs_scrub_cancel(root->fs_info);
475f6387
JS		 3237}
3238
3239static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
3240 void __user *arg)
3241{
3242 struct btrfs_ioctl_scrub_args *sa;
3243 int ret;
3244
3245 if (!capable(CAP_SYS_ADMIN))
3246 return -EPERM;
3247
3248 sa = memdup_user(arg, sizeof(*sa));
3249 if (IS_ERR(sa))
3250 return PTR_ERR(sa);
3251
3252 ret = btrfs_scrub_progress(root, sa->devid, &sa->progress);
3253
3254 if (copy_to_user(arg, sa, sizeof(*sa)))
3255 ret = -EFAULT;
3256
3257 kfree(sa);
3258 return ret;
3259}
3260
c11d2c23 3261static long btrfs_ioctl_get_dev_stats(struct btrfs_root *root,
b27f7c0c 3262 void __user *arg)
c11d2c23
SB		 3263{
3264 struct btrfs_ioctl_get_dev_stats *sa;
3265 int ret;
3266
c11d2c23
SB		 3267 sa = memdup_user(arg, sizeof(*sa));
3268 if (IS_ERR(sa))
3269 return PTR_ERR(sa);
3270
b27f7c0c
DS		 3271 if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) {
3272 kfree(sa);
3273 return -EPERM;
3274 }
3275
3276 ret = btrfs_get_dev_stats(root, sa);
c11d2c23
SB		 3277
3278 if (copy_to_user(arg, sa, sizeof(*sa)))
3279 ret = -EFAULT;
3280
3281 kfree(sa);
3282 return ret;
3283}
3284
3f6bcfbd
SB		 3285static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
3286{
3287 struct btrfs_ioctl_dev_replace_args *p;
3288 int ret;
3289
3290 if (!capable(CAP_SYS_ADMIN))
3291 return -EPERM;
3292
3293 p = memdup_user(arg, sizeof(*p));
3294 if (IS_ERR(p))
3295 return PTR_ERR(p);
3296
3297 switch (p->cmd) {
3298 case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
3299 if (atomic_xchg(
3300 &root->fs_info->mutually_exclusive_operation_running,
3301 1)) {
3302 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
3303 ret = -EINPROGRESS;
3304 } else {
3305 ret = btrfs_dev_replace_start(root, p);
3306 atomic_set(
3307 &root->fs_info->mutually_exclusive_operation_running,
3308 0);
3309 }
3310 break;
3311 case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
3312 btrfs_dev_replace_status(root->fs_info, p);
3313 ret = 0;
3314 break;
3315 case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
3316 ret = btrfs_dev_replace_cancel(root->fs_info, p);
3317 break;
3318 default:
3319 ret = -EINVAL;
3320 break;
3321 }
3322
3323 if (copy_to_user(arg, p, sizeof(*p)))
3324 ret = -EFAULT;
3325
3326 kfree(p);
3327 return ret;
3328}
3329
d7728c96
JS		 3330static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
3331{
3332 int ret = 0;
3333 int i;
740c3d22 3334 u64 rel_ptr;
d7728c96 3335 int size;
806468f8 3336 struct btrfs_ioctl_ino_path_args *ipa = NULL;
d7728c96
JS		 3337 struct inode_fs_paths *ipath = NULL;
3338 struct btrfs_path *path;
3339
82b22ac8 3340 if (!capable(CAP_DAC_READ_SEARCH))
d7728c96
JS		 3341 return -EPERM;
3342
3343 path = btrfs_alloc_path();
3344 if (!path) {
3345 ret = -ENOMEM;
3346 goto out;
3347 }
3348
3349 ipa = memdup_user(arg, sizeof(*ipa));
3350 if (IS_ERR(ipa)) {
3351 ret = PTR_ERR(ipa);
3352 ipa = NULL;
3353 goto out;
3354 }
3355
3356 size = min_t(u32, ipa->size, 4096);
3357 ipath = init_ipath(size, root, path);
3358 if (IS_ERR(ipath)) {
3359 ret = PTR_ERR(ipath);
3360 ipath = NULL;
3361 goto out;
3362 }
3363
3364 ret = paths_from_inode(ipa->inum, ipath);
3365 if (ret < 0)
3366 goto out;
3367
3368 for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
745c4d8e
JM		 3369 rel_ptr = ipath->fspath->val[i] -
3370 (u64)(unsigned long)ipath->fspath->val;
740c3d22 3371 ipath->fspath->val[i] = rel_ptr;
d7728c96
JS		 3372 }
3373
745c4d8e
JM		 3374 ret = copy_to_user((void *)(unsigned long)ipa->fspath,
3375 (void *)(unsigned long)ipath->fspath, size);
d7728c96
JS		 3376 if (ret) {
3377 ret = -EFAULT;
3378 goto out;
3379 }
3380
3381out:
3382 btrfs_free_path(path);
3383 free_ipath(ipath);
3384 kfree(ipa);
3385
3386 return ret;
3387}
3388
3389static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx)
3390{
3391 struct btrfs_data_container *inodes = ctx;
3392 const size_t c = 3 * sizeof(u64);
3393
3394 if (inodes->bytes_left >= c) {
3395 inodes->bytes_left -= c;
3396 inodes->val[inodes->elem_cnt] = inum;
3397 inodes->val[inodes->elem_cnt + 1] = offset;
3398 inodes->val[inodes->elem_cnt + 2] = root;
3399 inodes->elem_cnt += 3;
3400 } else {
3401 inodes->bytes_missing += c - inodes->bytes_left;
3402 inodes->bytes_left = 0;
3403 inodes->elem_missed += 3;
3404 }
3405
3406 return 0;
3407}
3408
3409static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
3410 void __user *arg)
3411{
3412 int ret = 0;
3413 int size;
d7728c96
JS		 3414 struct btrfs_ioctl_logical_ino_args *loi;
3415 struct btrfs_data_container *inodes = NULL;
3416 struct btrfs_path *path = NULL;
d7728c96
JS		 3417
3418 if (!capable(CAP_SYS_ADMIN))
3419 return -EPERM;
3420
3421 loi = memdup_user(arg, sizeof(*loi));
3422 if (IS_ERR(loi)) {
3423 ret = PTR_ERR(loi);
3424 loi = NULL;
3425 goto out;
3426 }
3427
3428 path = btrfs_alloc_path();
3429 if (!path) {
3430 ret = -ENOMEM;
3431 goto out;
3432 }
3433
425d17a2 3434 size = min_t(u32, loi->size, 64 * 1024);
d7728c96
JS		 3435 inodes = init_data_container(size);
3436 if (IS_ERR(inodes)) {
3437 ret = PTR_ERR(inodes);
3438 inodes = NULL;
3439 goto out;
3440 }
3441
df031f07
LB		 3442 ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path,
3443 build_ino_list, inodes);
3444 if (ret == -EINVAL)
d7728c96
JS		 3445 ret = -ENOENT;
3446 if (ret < 0)
3447 goto out;
3448
745c4d8e
JM		 3449 ret = copy_to_user((void *)(unsigned long)loi->inodes,
3450 (void *)(unsigned long)inodes, size);
d7728c96
JS		 3451 if (ret)
3452 ret = -EFAULT;
3453
3454out:
3455 btrfs_free_path(path);
425d17a2 3456 vfree(inodes);
d7728c96
JS		 3457 kfree(loi);
3458
3459 return ret;
3460}
3461
19a39dce 3462void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
c9e9f97b
ID		 3463 struct btrfs_ioctl_balance_args *bargs)
3464{
3465 struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3466
3467 bargs->flags = bctl->flags;
3468
837d5b6e
ID		 3469 if (atomic_read(&fs_info->balance_running))
3470 bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
3471 if (atomic_read(&fs_info->balance_pause_req))
3472 bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
a7e99c69
ID		 3473 if (atomic_read(&fs_info->balance_cancel_req))
3474 bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
837d5b6e 3475
c9e9f97b
ID		 3476 memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
3477 memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
3478 memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
19a39dce
ID		 3479
3480 if (lock) {
3481 spin_lock(&fs_info->balance_lock);
3482 memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
3483 spin_unlock(&fs_info->balance_lock);
3484 } else {
3485 memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
3486 }
c9e9f97b
ID		 3487}
3488
9ba1f6e4 3489static long btrfs_ioctl_balance(struct file *file, void __user *arg)
c9e9f97b 3490{
9ba1f6e4 3491 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
c9e9f97b
ID		 3492 struct btrfs_fs_info *fs_info = root->fs_info;
3493 struct btrfs_ioctl_balance_args *bargs;
3494 struct btrfs_balance_control *bctl;
ed0fb78f 3495 bool need_unlock; /* for mut. excl. ops lock */
c9e9f97b
ID		 3496 int ret;
3497
3498 if (!capable(CAP_SYS_ADMIN))
3499 return -EPERM;
3500
e54bfa31 3501 ret = mnt_want_write_file(file);
9ba1f6e4
LB		 3502 if (ret)
3503 return ret;
3504
ed0fb78f
ID		 3505again:
3506 if (!atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1)) {
3507 mutex_lock(&fs_info->volume_mutex);
3508 mutex_lock(&fs_info->balance_mutex);
3509 need_unlock = true;
3510 goto locked;
3511 }
3512
3513 /*
3514 * mut. excl. ops lock is locked. Three possibilites:
3515 * (1) some other op is running
3516 * (2) balance is running
3517 * (3) balance is paused -- special case (think resume)
3518 */
c9e9f97b 3519 mutex_lock(&fs_info->balance_mutex);
ed0fb78f
ID		 3520 if (fs_info->balance_ctl) {
3521 /* this is either (2) or (3) */
3522 if (!atomic_read(&fs_info->balance_running)) {
3523 mutex_unlock(&fs_info->balance_mutex);
3524 if (!mutex_trylock(&fs_info->volume_mutex))
3525 goto again;
3526 mutex_lock(&fs_info->balance_mutex);
3527
3528 if (fs_info->balance_ctl &&
3529 !atomic_read(&fs_info->balance_running)) {
3530 /* this is (3) */
3531 need_unlock = false;
3532 goto locked;
3533 }
3534
3535 mutex_unlock(&fs_info->balance_mutex);
3536 mutex_unlock(&fs_info->volume_mutex);
3537 goto again;
3538 } else {
3539 /* this is (2) */
3540 mutex_unlock(&fs_info->balance_mutex);
3541 ret = -EINPROGRESS;
3542 goto out;
3543 }
3544 } else {
3545 /* this is (1) */
3546 mutex_unlock(&fs_info->balance_mutex);
3547 pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
3548 ret = -EINVAL;
3549 goto out;
3550 }
3551
3552locked:
3553 BUG_ON(!atomic_read(&fs_info->mutually_exclusive_operation_running));
c9e9f97b
ID		 3554
3555 if (arg) {
3556 bargs = memdup_user(arg, sizeof(*bargs));
3557 if (IS_ERR(bargs)) {
3558 ret = PTR_ERR(bargs);
ed0fb78f 3559 goto out_unlock;
c9e9f97b 3560 }
de322263
ID		 3561
3562 if (bargs->flags & BTRFS_BALANCE_RESUME) {
3563 if (!fs_info->balance_ctl) {
3564 ret = -ENOTCONN;
3565 goto out_bargs;
3566 }
3567
3568 bctl = fs_info->balance_ctl;
3569 spin_lock(&fs_info->balance_lock);
3570 bctl->flags |= BTRFS_BALANCE_RESUME;
3571 spin_unlock(&fs_info->balance_lock);
3572
3573 goto do_balance;
3574 }
c9e9f97b
ID		 3575 } else {
3576 bargs = NULL;
3577 }
3578
ed0fb78f 3579 if (fs_info->balance_ctl) {
837d5b6e
ID		 3580 ret = -EINPROGRESS;
3581 goto out_bargs;
3582 }
3583
c9e9f97b
ID		 3584 bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
3585 if (!bctl) {
3586 ret = -ENOMEM;
3587 goto out_bargs;
3588 }
3589
3590 bctl->fs_info = fs_info;
3591 if (arg) {
3592 memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
3593 memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
3594 memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));
3595
3596 bctl->flags = bargs->flags;
f43ffb60
ID		 3597 } else {
3598 /* balance everything - no filters */
3599 bctl->flags |= BTRFS_BALANCE_TYPE_MASK;
c9e9f97b
ID		 3600 }
3601
de322263 3602do_balance:
c9e9f97b 3603 /*
ed0fb78f
ID		 3604 * Ownership of bctl and mutually_exclusive_operation_running
3605 * goes to to btrfs_balance. bctl is freed in __cancel_balance,
3606 * or, if restriper was paused all the way until unmount, in
3607 * free_fs_info. mutually_exclusive_operation_running is
3608 * cleared in __cancel_balance.
c9e9f97b 3609 */
ed0fb78f
ID		 3610 need_unlock = false;
3611
3612 ret = btrfs_balance(bctl, bargs);
3613
c9e9f97b
ID		 3614 if (arg) {
3615 if (copy_to_user(arg, bargs, sizeof(*bargs)))
3616 ret = -EFAULT;
3617 }
3618
3619out_bargs:
3620 kfree(bargs);
ed0fb78f 3621out_unlock:
c9e9f97b
ID		 3622 mutex_unlock(&fs_info->balance_mutex);
3623 mutex_unlock(&fs_info->volume_mutex);
ed0fb78f
ID		 3624 if (need_unlock)
3625 atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
3626out:
e54bfa31 3627 mnt_drop_write_file(file);
c9e9f97b
ID		 3628 return ret;
3629}
3630
837d5b6e
ID		 3631static long btrfs_ioctl_balance_ctl(struct btrfs_root *root, int cmd)
3632{
3633 if (!capable(CAP_SYS_ADMIN))
3634 return -EPERM;
3635
3636 switch (cmd) {
3637 case BTRFS_BALANCE_CTL_PAUSE:
3638 return btrfs_pause_balance(root->fs_info);
a7e99c69
ID		 3639 case BTRFS_BALANCE_CTL_CANCEL:
3640 return btrfs_cancel_balance(root->fs_info);
837d5b6e
ID		 3641 }
3642
3643 return -EINVAL;
3644}
3645
19a39dce
ID		 3646static long btrfs_ioctl_balance_progress(struct btrfs_root *root,
3647 void __user *arg)
3648{
3649 struct btrfs_fs_info *fs_info = root->fs_info;
3650 struct btrfs_ioctl_balance_args *bargs;
3651 int ret = 0;
3652
3653 if (!capable(CAP_SYS_ADMIN))
3654 return -EPERM;
3655
3656 mutex_lock(&fs_info->balance_mutex);
3657 if (!fs_info->balance_ctl) {
3658 ret = -ENOTCONN;
3659 goto out;
3660 }
3661
3662 bargs = kzalloc(sizeof(*bargs), GFP_NOFS);
3663 if (!bargs) {
3664 ret = -ENOMEM;
3665 goto out;
3666 }
3667
3668 update_ioctl_balance_args(fs_info, 1, bargs);
3669
3670 if (copy_to_user(arg, bargs, sizeof(*bargs)))
3671 ret = -EFAULT;
3672
3673 kfree(bargs);
3674out:
3675 mutex_unlock(&fs_info->balance_mutex);
3676 return ret;
3677}
3678
905b0dda 3679static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
5d13a37b 3680{
905b0dda 3681 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
5d13a37b
AJ		 3682 struct btrfs_ioctl_quota_ctl_args *sa;
3683 struct btrfs_trans_handle *trans = NULL;
3684 int ret;
3685 int err;
3686
3687 if (!capable(CAP_SYS_ADMIN))
3688 return -EPERM;
3689
905b0dda
MX		 3690 ret = mnt_want_write_file(file);
3691 if (ret)
3692 return ret;
5d13a37b
AJ		 3693
3694 sa = memdup_user(arg, sizeof(*sa));
905b0dda
MX		 3695 if (IS_ERR(sa)) {
3696 ret = PTR_ERR(sa);
3697 goto drop_write;
3698 }
5d13a37b
AJ		 3699
3700 if (sa->cmd != BTRFS_QUOTA_CTL_RESCAN) {
3701 trans = btrfs_start_transaction(root, 2);
3702 if (IS_ERR(trans)) {
3703 ret = PTR_ERR(trans);
3704 goto out;
3705 }
3706 }
3707
3708 switch (sa->cmd) {
3709 case BTRFS_QUOTA_CTL_ENABLE:
3710 ret = btrfs_quota_enable(trans, root->fs_info);
3711 break;
3712 case BTRFS_QUOTA_CTL_DISABLE:
3713 ret = btrfs_quota_disable(trans, root->fs_info);
3714 break;
3715 case BTRFS_QUOTA_CTL_RESCAN:
3716 ret = btrfs_quota_rescan(root->fs_info);
3717 break;
3718 default:
3719 ret = -EINVAL;
3720 break;
3721 }
3722
3723 if (copy_to_user(arg, sa, sizeof(*sa)))
3724 ret = -EFAULT;
3725
3726 if (trans) {
3727 err = btrfs_commit_transaction(trans, root);
3728 if (err && !ret)
3729 ret = err;
3730 }
5d13a37b
AJ		 3731out:
3732 kfree(sa);
905b0dda
MX		 3733drop_write:
3734 mnt_drop_write_file(file);
5d13a37b
AJ		 3735 return ret;
3736}
3737
905b0dda 3738static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
5d13a37b 3739{
905b0dda 3740 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
5d13a37b
AJ		 3741 struct btrfs_ioctl_qgroup_assign_args *sa;
3742 struct btrfs_trans_handle *trans;
3743 int ret;
3744 int err;
3745
3746 if (!capable(CAP_SYS_ADMIN))
3747 return -EPERM;
3748
905b0dda
MX		 3749 ret = mnt_want_write_file(file);
3750 if (ret)
3751 return ret;
5d13a37b
AJ		 3752
3753 sa = memdup_user(arg, sizeof(*sa));
905b0dda
MX		 3754 if (IS_ERR(sa)) {
3755 ret = PTR_ERR(sa);
3756 goto drop_write;
3757 }
5d13a37b
AJ		 3758
3759 trans = btrfs_join_transaction(root);
3760 if (IS_ERR(trans)) {
3761 ret = PTR_ERR(trans);
3762 goto out;
3763 }
3764
3765 /* FIXME: check if the IDs really exist */
3766 if (sa->assign) {
3767 ret = btrfs_add_qgroup_relation(trans, root->fs_info,
3768 sa->src, sa->dst);
3769 } else {
3770 ret = btrfs_del_qgroup_relation(trans, root->fs_info,
3771 sa->src, sa->dst);
3772 }
3773
3774 err = btrfs_end_transaction(trans, root);
3775 if (err && !ret)
3776 ret = err;
3777
3778out:
3779 kfree(sa);
905b0dda
MX		 3780drop_write:
3781 mnt_drop_write_file(file);
5d13a37b
AJ		 3782 return ret;
3783}
3784
905b0dda 3785static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
5d13a37b 3786{
905b0dda 3787 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
5d13a37b
AJ		 3788 struct btrfs_ioctl_qgroup_create_args *sa;
3789 struct btrfs_trans_handle *trans;
3790 int ret;
3791 int err;
3792
3793 if (!capable(CAP_SYS_ADMIN))
3794 return -EPERM;
3795
905b0dda
MX		 3796 ret = mnt_want_write_file(file);
3797 if (ret)
3798 return ret;
5d13a37b
AJ		 3799
3800 sa = memdup_user(arg, sizeof(*sa));
905b0dda
MX		 3801 if (IS_ERR(sa)) {
3802 ret = PTR_ERR(sa);
3803 goto drop_write;
3804 }
5d13a37b 3805
d86e56cf
MX		 3806 if (!sa->qgroupid) {
3807 ret = -EINVAL;
3808 goto out;
3809 }
3810
5d13a37b
AJ		 3811 trans = btrfs_join_transaction(root);
3812 if (IS_ERR(trans)) {
3813 ret = PTR_ERR(trans);
3814 goto out;
3815 }
3816
3817 /* FIXME: check if the IDs really exist */
3818 if (sa->create) {
3819 ret = btrfs_create_qgroup(trans, root->fs_info, sa->qgroupid,
3820 NULL);
3821 } else {
3822 ret = btrfs_remove_qgroup(trans, root->fs_info, sa->qgroupid);
3823 }
3824
3825 err = btrfs_end_transaction(trans, root);
3826 if (err && !ret)
3827 ret = err;
3828
3829out:
3830 kfree(sa);
905b0dda
MX		 3831drop_write:
3832 mnt_drop_write_file(file);
5d13a37b
AJ		 3833 return ret;
3834}
3835
905b0dda 3836static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
5d13a37b 3837{
905b0dda 3838 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
5d13a37b
AJ		 3839 struct btrfs_ioctl_qgroup_limit_args *sa;
3840 struct btrfs_trans_handle *trans;
3841 int ret;
3842 int err;
3843 u64 qgroupid;
3844
3845 if (!capable(CAP_SYS_ADMIN))
3846 return -EPERM;
3847
905b0dda
MX		 3848 ret = mnt_want_write_file(file);
3849 if (ret)
3850 return ret;
5d13a37b
AJ		 3851
3852 sa = memdup_user(arg, sizeof(*sa));
905b0dda
MX		 3853 if (IS_ERR(sa)) {
3854 ret = PTR_ERR(sa);
3855 goto drop_write;
3856 }
5d13a37b
AJ		 3857
3858 trans = btrfs_join_transaction(root);
3859 if (IS_ERR(trans)) {
3860 ret = PTR_ERR(trans);
3861 goto out;
3862 }
3863
3864 qgroupid = sa->qgroupid;
3865 if (!qgroupid) {
3866 /* take the current subvol as qgroup */
3867 qgroupid = root->root_key.objectid;
3868 }
3869
3870 /* FIXME: check if the IDs really exist */
3871 ret = btrfs_limit_qgroup(trans, root->fs_info, qgroupid, &sa->lim);
3872
3873 err = btrfs_end_transaction(trans, root);
3874 if (err && !ret)
3875 ret = err;
3876
3877out:
3878 kfree(sa);
905b0dda
MX		 3879drop_write:
3880 mnt_drop_write_file(file);
5d13a37b
AJ		 3881 return ret;
3882}
3883
8ea05e3a
AB		 3884static long btrfs_ioctl_set_received_subvol(struct file *file,
3885 void __user *arg)
3886{
3887 struct btrfs_ioctl_received_subvol_args *sa = NULL;
3888 struct inode *inode = fdentry(file)->d_inode;
3889 struct btrfs_root *root = BTRFS_I(inode)->root;
3890 struct btrfs_root_item *root_item = &root->root_item;
3891 struct btrfs_trans_handle *trans;
3892 struct timespec ct = CURRENT_TIME;
3893 int ret = 0;
3894
3895 ret = mnt_want_write_file(file);
3896 if (ret < 0)
3897 return ret;
3898
3899 down_write(&root->fs_info->subvol_sem);
3900
3901 if (btrfs_ino(inode) != BTRFS_FIRST_FREE_OBJECTID) {
3902 ret = -EINVAL;
3903 goto out;
3904 }
3905
3906 if (btrfs_root_readonly(root)) {
3907 ret = -EROFS;
3908 goto out;
3909 }
3910
3911 if (!inode_owner_or_capable(inode)) {
3912 ret = -EACCES;
3913 goto out;
3914 }
3915
3916 sa = memdup_user(arg, sizeof(*sa));
3917 if (IS_ERR(sa)) {
3918 ret = PTR_ERR(sa);
3919 sa = NULL;
3920 goto out;
3921 }
3922
3923 trans = btrfs_start_transaction(root, 1);
3924 if (IS_ERR(trans)) {
3925 ret = PTR_ERR(trans);
3926 trans = NULL;
3927 goto out;
3928 }
3929
3930 sa->rtransid = trans->transid;
3931 sa->rtime.sec = ct.tv_sec;
3932 sa->rtime.nsec = ct.tv_nsec;
3933
3934 memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
3935 btrfs_set_root_stransid(root_item, sa->stransid);
3936 btrfs_set_root_rtransid(root_item, sa->rtransid);
3937 root_item->stime.sec = cpu_to_le64(sa->stime.sec);
3938 root_item->stime.nsec = cpu_to_le32(sa->stime.nsec);
3939 root_item->rtime.sec = cpu_to_le64(sa->rtime.sec);
3940 root_item->rtime.nsec = cpu_to_le32(sa->rtime.nsec);
3941
3942 ret = btrfs_update_root(trans, root->fs_info->tree_root,
3943 &root->root_key, &root->root_item);
3944 if (ret < 0) {
3945 btrfs_end_transaction(trans, root);
3946 trans = NULL;
3947 goto out;
3948 } else {
3949 ret = btrfs_commit_transaction(trans, root);
3950 if (ret < 0)
3951 goto out;
3952 }
3953
3954 ret = copy_to_user(arg, sa, sizeof(*sa));
3955 if (ret)
3956 ret = -EFAULT;
3957
3958out:
3959 kfree(sa);
3960 up_write(&root->fs_info->subvol_sem);
3961 mnt_drop_write_file(file);
3962 return ret;
3963}
3964
867ab667 3965static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg)
3966{
3967 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
3968 const char *label = root->fs_info->super_copy->label;
3969 size_t len = strnlen(label, BTRFS_LABEL_SIZE);
3970 int ret;
3971
3972 if (len == BTRFS_LABEL_SIZE) {
3973 pr_warn("btrfs: label is too long, return the first %zu bytes\n",
3974 --len);
3975 }
3976
3977 mutex_lock(&root->fs_info->volume_mutex);
3978 ret = copy_to_user(arg, label, len);
3979 mutex_unlock(&root->fs_info->volume_mutex);
3980
3981 return ret ? -EFAULT : 0;
3982}
3983
a8bfd4ab 3984static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
3985{
3986 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
3987 struct btrfs_super_block *super_block = root->fs_info->super_copy;
3988 struct btrfs_trans_handle *trans;
3989 char label[BTRFS_LABEL_SIZE];
3990 int ret;
3991
3992 if (!capable(CAP_SYS_ADMIN))
3993 return -EPERM;
3994
3995 if (copy_from_user(label, arg, sizeof(label)))
3996 return -EFAULT;
3997
3998 if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
3999 pr_err("btrfs: unable to set label with more than %d bytes\n",
4000 BTRFS_LABEL_SIZE - 1);
4001 return -EINVAL;
4002 }
4003
4004 ret = mnt_want_write_file(file);
4005 if (ret)
4006 return ret;
4007
4008 mutex_lock(&root->fs_info->volume_mutex);
4009 trans = btrfs_start_transaction(root, 0);
4010 if (IS_ERR(trans)) {
4011 ret = PTR_ERR(trans);
4012 goto out_unlock;
4013 }
4014
4015 strcpy(super_block->label, label);
4016 ret = btrfs_end_transaction(trans, root);
4017
4018out_unlock:
4019 mutex_unlock(&root->fs_info->volume_mutex);
4020 mnt_drop_write_file(file);
4021 return ret;
4022}
4023
f46b5a66
CH		 4024long btrfs_ioctl(struct file *file, unsigned int
4025 cmd, unsigned long arg)
4026{
4027 struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
4bcabaa3 4028 void __user *argp = (void __user *)arg;
f46b5a66
CH		 4029
4030 switch (cmd) {
6cbff00f
CH		 4031 case FS_IOC_GETFLAGS:
4032 return btrfs_ioctl_getflags(file, argp);
4033 case FS_IOC_SETFLAGS:
4034 return btrfs_ioctl_setflags(file, argp);
4035 case FS_IOC_GETVERSION:
4036 return btrfs_ioctl_getversion(file, argp);
f7039b1d
LD		 4037 case FITRIM:
4038 return btrfs_ioctl_fitrim(file, argp);
f46b5a66 4039 case BTRFS_IOC_SNAP_CREATE:
fa0d2b9b 4040 return btrfs_ioctl_snap_create(file, argp, 0);
fdfb1e4f 4041 case BTRFS_IOC_SNAP_CREATE_V2:
fa0d2b9b 4042 return btrfs_ioctl_snap_create_v2(file, argp, 0);
3de4586c 4043 case BTRFS_IOC_SUBVOL_CREATE:
fa0d2b9b 4044 return btrfs_ioctl_snap_create(file, argp, 1);
6f72c7e2
AJ		 4045 case BTRFS_IOC_SUBVOL_CREATE_V2:
4046 return btrfs_ioctl_snap_create_v2(file, argp, 1);
76dda93c
YZ		 4047 case BTRFS_IOC_SNAP_DESTROY:
4048 return btrfs_ioctl_snap_destroy(file, argp);
0caa102d
LZ		 4049 case BTRFS_IOC_SUBVOL_GETFLAGS:
4050 return btrfs_ioctl_subvol_getflags(file, argp);
4051 case BTRFS_IOC_SUBVOL_SETFLAGS:
4052 return btrfs_ioctl_subvol_setflags(file, argp);
6ef5ed0d
JB		 4053 case BTRFS_IOC_DEFAULT_SUBVOL:
4054 return btrfs_ioctl_default_subvol(file, argp);
f46b5a66 4055 case BTRFS_IOC_DEFRAG:
1e701a32
CM		 4056 return btrfs_ioctl_defrag(file, NULL);
4057 case BTRFS_IOC_DEFRAG_RANGE:
4058 return btrfs_ioctl_defrag(file, argp);
f46b5a66 4059 case BTRFS_IOC_RESIZE:
198605a8 4060 return btrfs_ioctl_resize(file, argp);
f46b5a66 4061 case BTRFS_IOC_ADD_DEV:
4bcabaa3 4062 return btrfs_ioctl_add_dev(root, argp);
f46b5a66 4063 case BTRFS_IOC_RM_DEV:
da24927b 4064 return btrfs_ioctl_rm_dev(file, argp);
475f6387
JS		 4065 case BTRFS_IOC_FS_INFO:
4066 return btrfs_ioctl_fs_info(root, argp);
4067 case BTRFS_IOC_DEV_INFO:
4068 return btrfs_ioctl_dev_info(root, argp);
f46b5a66 4069 case BTRFS_IOC_BALANCE:
9ba1f6e4 4070 return btrfs_ioctl_balance(file, NULL);
f46b5a66 4071 case BTRFS_IOC_CLONE:
c5c9cd4d
SW		 4072 return btrfs_ioctl_clone(file, arg, 0, 0, 0);
4073 case BTRFS_IOC_CLONE_RANGE:
7a865e8a 4074 return btrfs_ioctl_clone_range(file, argp);
f46b5a66
CH		 4075 case BTRFS_IOC_TRANS_START:
4076 return btrfs_ioctl_trans_start(file);
4077 case BTRFS_IOC_TRANS_END:
4078 return btrfs_ioctl_trans_end(file);
ac8e9819
CM		 4079 case BTRFS_IOC_TREE_SEARCH:
4080 return btrfs_ioctl_tree_search(file, argp);
4081 case BTRFS_IOC_INO_LOOKUP:
4082 return btrfs_ioctl_ino_lookup(file, argp);
d7728c96
JS		 4083 case BTRFS_IOC_INO_PATHS:
4084 return btrfs_ioctl_ino_to_path(root, argp);
4085 case BTRFS_IOC_LOGICAL_INO:
4086 return btrfs_ioctl_logical_to_ino(root, argp);
1406e432
JB		 4087 case BTRFS_IOC_SPACE_INFO:
4088 return btrfs_ioctl_space_info(root, argp);
f46b5a66
CH		 4089 case BTRFS_IOC_SYNC:
4090 btrfs_sync_fs(file->f_dentry->d_sb, 1);
4091 return 0;
46204592 4092 case BTRFS_IOC_START_SYNC:
9a8c28be 4093 return btrfs_ioctl_start_sync(root, argp);
46204592 4094 case BTRFS_IOC_WAIT_SYNC:
9a8c28be 4095 return btrfs_ioctl_wait_sync(root, argp);
475f6387 4096 case BTRFS_IOC_SCRUB:
b8e95489 4097 return btrfs_ioctl_scrub(file, argp);
475f6387
JS		 4098 case BTRFS_IOC_SCRUB_CANCEL:
4099 return btrfs_ioctl_scrub_cancel(root, argp);
4100 case BTRFS_IOC_SCRUB_PROGRESS:
4101 return btrfs_ioctl_scrub_progress(root, argp);
c9e9f97b 4102 case BTRFS_IOC_BALANCE_V2:
9ba1f6e4 4103 return btrfs_ioctl_balance(file, argp);
837d5b6e
ID		 4104 case BTRFS_IOC_BALANCE_CTL:
4105 return btrfs_ioctl_balance_ctl(root, arg);
19a39dce
ID		 4106 case BTRFS_IOC_BALANCE_PROGRESS:
4107 return btrfs_ioctl_balance_progress(root, argp);
8ea05e3a
AB		 4108 case BTRFS_IOC_SET_RECEIVED_SUBVOL:
4109 return btrfs_ioctl_set_received_subvol(file, argp);
31db9f7c
AB		 4110 case BTRFS_IOC_SEND:
4111 return btrfs_ioctl_send(file, argp);
c11d2c23 4112 case BTRFS_IOC_GET_DEV_STATS:
b27f7c0c 4113 return btrfs_ioctl_get_dev_stats(root, argp);
5d13a37b 4114 case BTRFS_IOC_QUOTA_CTL:
905b0dda 4115 return btrfs_ioctl_quota_ctl(file, argp);
5d13a37b 4116 case BTRFS_IOC_QGROUP_ASSIGN:
905b0dda 4117 return btrfs_ioctl_qgroup_assign(file, argp);
5d13a37b 4118 case BTRFS_IOC_QGROUP_CREATE:
905b0dda 4119 return btrfs_ioctl_qgroup_create(file, argp);
5d13a37b 4120 case BTRFS_IOC_QGROUP_LIMIT:
905b0dda 4121 return btrfs_ioctl_qgroup_limit(file, argp);
3f6bcfbd
SB		 4122 case BTRFS_IOC_DEV_REPLACE:
4123 return btrfs_ioctl_dev_replace(root, argp);
867ab667 4124 case BTRFS_IOC_GET_FSLABEL:
4125 return btrfs_ioctl_get_fslabel(file, argp);
a8bfd4ab 4126 case BTRFS_IOC_SET_FSLABEL:
4127 return btrfs_ioctl_set_fslabel(file, argp);
f46b5a66
CH		 4128 }
4129
4130 return -ENOTTY;
4131}
Linux kernel - Deliverables
This page took 0.555934 seconds and 5 git commands to generate.