Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (C) 2007 Oracle. All rights reserved.
4 : */
5 :
6 : #include <linux/kernel.h>
7 : #include <linux/bio.h>
8 : #include <linux/file.h>
9 : #include <linux/fs.h>
10 : #include <linux/fsnotify.h>
11 : #include <linux/pagemap.h>
12 : #include <linux/highmem.h>
13 : #include <linux/time.h>
14 : #include <linux/string.h>
15 : #include <linux/backing-dev.h>
16 : #include <linux/mount.h>
17 : #include <linux/namei.h>
18 : #include <linux/writeback.h>
19 : #include <linux/compat.h>
20 : #include <linux/security.h>
21 : #include <linux/xattr.h>
22 : #include <linux/mm.h>
23 : #include <linux/slab.h>
24 : #include <linux/blkdev.h>
25 : #include <linux/uuid.h>
26 : #include <linux/btrfs.h>
27 : #include <linux/uaccess.h>
28 : #include <linux/iversion.h>
29 : #include <linux/fileattr.h>
30 : #include <linux/fsverity.h>
31 : #include <linux/sched/xacct.h>
32 : #include "ctree.h"
33 : #include "disk-io.h"
34 : #include "export.h"
35 : #include "transaction.h"
36 : #include "btrfs_inode.h"
37 : #include "print-tree.h"
38 : #include "volumes.h"
39 : #include "locking.h"
40 : #include "backref.h"
41 : #include "rcu-string.h"
42 : #include "send.h"
43 : #include "dev-replace.h"
44 : #include "props.h"
45 : #include "sysfs.h"
46 : #include "qgroup.h"
47 : #include "tree-log.h"
48 : #include "compression.h"
49 : #include "space-info.h"
50 : #include "delalloc-space.h"
51 : #include "block-group.h"
52 : #include "subpage.h"
53 : #include "fs.h"
54 : #include "accessors.h"
55 : #include "extent-tree.h"
56 : #include "root-tree.h"
57 : #include "defrag.h"
58 : #include "dir-item.h"
59 : #include "uuid-tree.h"
60 : #include "ioctl.h"
61 : #include "file.h"
62 : #include "scrub.h"
63 : #include "super.h"
64 :
65 : #ifdef CONFIG_64BIT
66 : /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI
67 : * structures are incorrect, as the timespec structure from userspace
68 : * is 4 bytes too small. We define these alternatives here to teach
69 : * the kernel about the 32-bit struct packing.
70 : */
71 : struct btrfs_ioctl_timespec_32 {
72 : __u64 sec;
73 : __u32 nsec;
74 : } __attribute__ ((__packed__));
75 :
76 : struct btrfs_ioctl_received_subvol_args_32 {
77 : char uuid[BTRFS_UUID_SIZE]; /* in */
78 : __u64 stransid; /* in */
79 : __u64 rtransid; /* out */
80 : struct btrfs_ioctl_timespec_32 stime; /* in */
81 : struct btrfs_ioctl_timespec_32 rtime; /* out */
82 : __u64 flags; /* in */
83 : __u64 reserved[16]; /* in */
84 : } __attribute__ ((__packed__));
85 :
86 : #define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 _IOWR(BTRFS_IOCTL_MAGIC, 37, \
87 : struct btrfs_ioctl_received_subvol_args_32)
88 : #endif
89 :
90 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
91 : struct btrfs_ioctl_send_args_32 {
92 : __s64 send_fd; /* in */
93 : __u64 clone_sources_count; /* in */
94 : compat_uptr_t clone_sources; /* in */
95 : __u64 parent_root; /* in */
96 : __u64 flags; /* in */
97 : __u32 version; /* in */
98 : __u8 reserved[28]; /* in */
99 : } __attribute__ ((__packed__));
100 :
101 : #define BTRFS_IOC_SEND_32 _IOW(BTRFS_IOCTL_MAGIC, 38, \
102 : struct btrfs_ioctl_send_args_32)
103 :
104 : struct btrfs_ioctl_encoded_io_args_32 {
105 : compat_uptr_t iov;
106 : compat_ulong_t iovcnt;
107 : __s64 offset;
108 : __u64 flags;
109 : __u64 len;
110 : __u64 unencoded_len;
111 : __u64 unencoded_offset;
112 : __u32 compression;
113 : __u32 encryption;
114 : __u8 reserved[64];
115 : };
116 :
117 : #define BTRFS_IOC_ENCODED_READ_32 _IOR(BTRFS_IOCTL_MAGIC, 64, \
118 : struct btrfs_ioctl_encoded_io_args_32)
119 : #define BTRFS_IOC_ENCODED_WRITE_32 _IOW(BTRFS_IOCTL_MAGIC, 64, \
120 : struct btrfs_ioctl_encoded_io_args_32)
121 : #endif
122 :
123 : /* Mask out flags that are inappropriate for the given type of inode. */
124 : static unsigned int btrfs_mask_fsflags_for_type(struct inode *inode,
125 : unsigned int flags)
126 : {
127 981 : if (S_ISDIR(inode->i_mode))
128 : return flags;
129 971 : else if (S_ISREG(inode->i_mode))
130 971 : return flags & ~FS_DIRSYNC_FL;
131 : else
132 0 : return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
133 : }
134 :
135 : /*
136 : * Export internal inode flags to the format expected by the FS_IOC_GETFLAGS
137 : * ioctl.
138 : */
139 9947 : static unsigned int btrfs_inode_flags_to_fsflags(struct btrfs_inode *binode)
140 : {
141 9947 : unsigned int iflags = 0;
142 9947 : u32 flags = binode->flags;
143 9947 : u32 ro_flags = binode->ro_flags;
144 :
145 9947 : if (flags & BTRFS_INODE_SYNC)
146 14 : iflags |= FS_SYNC_FL;
147 9947 : if (flags & BTRFS_INODE_IMMUTABLE)
148 91 : iflags |= FS_IMMUTABLE_FL;
149 9947 : if (flags & BTRFS_INODE_APPEND)
150 81 : iflags |= FS_APPEND_FL;
151 9947 : if (flags & BTRFS_INODE_NODUMP)
152 30 : iflags |= FS_NODUMP_FL;
153 9947 : if (flags & BTRFS_INODE_NOATIME)
154 9 : iflags |= FS_NOATIME_FL;
155 9947 : if (flags & BTRFS_INODE_DIRSYNC)
156 0 : iflags |= FS_DIRSYNC_FL;
157 9947 : if (flags & BTRFS_INODE_NODATACOW)
158 23 : iflags |= FS_NOCOW_FL;
159 9947 : if (ro_flags & BTRFS_INODE_RO_VERITY)
160 0 : iflags |= FS_VERITY_FL;
161 :
162 9947 : if (flags & BTRFS_INODE_NOCOMPRESS)
163 2 : iflags |= FS_NOCOMP_FL;
164 9945 : else if (flags & BTRFS_INODE_COMPRESS)
165 42 : iflags |= FS_COMPR_FL;
166 :
167 9947 : return iflags;
168 : }
169 :
170 : /*
171 : * Update inode->i_flags based on the btrfs internal flags.
172 : */
173 3828187 : void btrfs_sync_inode_flags_to_i_flags(struct inode *inode)
174 : {
175 3828187 : struct btrfs_inode *binode = BTRFS_I(inode);
176 3828187 : unsigned int new_fl = 0;
177 :
178 3828187 : if (binode->flags & BTRFS_INODE_SYNC)
179 42 : new_fl |= S_SYNC;
180 3828187 : if (binode->flags & BTRFS_INODE_IMMUTABLE)
181 27 : new_fl |= S_IMMUTABLE;
182 3828187 : if (binode->flags & BTRFS_INODE_APPEND)
183 24 : new_fl |= S_APPEND;
184 3828187 : if (binode->flags & BTRFS_INODE_NOATIME)
185 3 : new_fl |= S_NOATIME;
186 3828187 : if (binode->flags & BTRFS_INODE_DIRSYNC)
187 0 : new_fl |= S_DIRSYNC;
188 3828187 : if (binode->ro_flags & BTRFS_INODE_RO_VERITY)
189 0 : new_fl |= S_VERITY;
190 :
191 3828187 : set_mask_bits(&inode->i_flags,
192 : S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | S_DIRSYNC |
193 : S_VERITY, new_fl);
194 3828011 : }
195 :
196 : /*
197 : * Check if @flags are a supported and valid set of FS_*_FL flags and that
198 : * the old and new flags are not conflicting
199 : */
200 981 : static int check_fsflags(unsigned int old_flags, unsigned int flags)
201 : {
202 981 : if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
203 : FS_NOATIME_FL | FS_NODUMP_FL | \
204 : FS_SYNC_FL | FS_DIRSYNC_FL | \
205 : FS_NOCOMP_FL | FS_COMPR_FL |
206 : FS_NOCOW_FL))
207 : return -EOPNOTSUPP;
208 :
209 : /* COMPR and NOCOMP on new/old are valid */
210 618 : if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
211 : return -EINVAL;
212 :
213 618 : if ((flags & FS_COMPR_FL) && (flags & FS_NOCOW_FL))
214 : return -EINVAL;
215 :
216 : /* NOCOW and compression options are mutually exclusive */
217 615 : if ((old_flags & FS_NOCOW_FL) && (flags & (FS_COMPR_FL | FS_NOCOMP_FL)))
218 : return -EINVAL;
219 615 : if ((flags & FS_NOCOW_FL) && (old_flags & (FS_COMPR_FL | FS_NOCOMP_FL)))
220 0 : return -EINVAL;
221 :
222 : return 0;
223 : }
224 :
225 : static int check_fsflags_compatible(struct btrfs_fs_info *fs_info,
226 : unsigned int flags)
227 : {
228 : if (btrfs_is_zoned(fs_info) && (flags & FS_NOCOW_FL))
229 : return -EPERM;
230 :
231 : return 0;
232 : }
233 :
234 : /*
235 : * Set flags/xflags from the internal inode flags. The remaining items of
236 : * fsxattr are zeroed.
237 : */
238 8966 : int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
239 : {
240 8966 : struct btrfs_inode *binode = BTRFS_I(d_inode(dentry));
241 :
242 8966 : fileattr_fill_flags(fa, btrfs_inode_flags_to_fsflags(binode));
243 8966 : return 0;
244 : }
245 :
246 4116 : int btrfs_fileattr_set(struct mnt_idmap *idmap,
247 : struct dentry *dentry, struct fileattr *fa)
248 : {
249 4116 : struct inode *inode = d_inode(dentry);
250 4116 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
251 4116 : struct btrfs_inode *binode = BTRFS_I(inode);
252 4116 : struct btrfs_root *root = binode->root;
253 4116 : struct btrfs_trans_handle *trans;
254 4116 : unsigned int fsflags, old_fsflags;
255 4116 : int ret;
256 4116 : const char *comp = NULL;
257 4116 : u32 binode_flags;
258 :
259 4116 : if (btrfs_root_readonly(root))
260 : return -EROFS;
261 :
262 4116 : if (fileattr_has_fsx(fa))
263 : return -EOPNOTSUPP;
264 :
265 981 : fsflags = btrfs_mask_fsflags_for_type(inode, fa->flags);
266 981 : old_fsflags = btrfs_inode_flags_to_fsflags(binode);
267 981 : ret = check_fsflags(old_fsflags, fsflags);
268 981 : if (ret)
269 : return ret;
270 :
271 615 : ret = check_fsflags_compatible(fs_info, fsflags);
272 615 : if (ret)
273 : return ret;
274 :
275 615 : binode_flags = binode->flags;
276 615 : if (fsflags & FS_SYNC_FL)
277 8 : binode_flags |= BTRFS_INODE_SYNC;
278 : else
279 607 : binode_flags &= ~BTRFS_INODE_SYNC;
280 615 : if (fsflags & FS_IMMUTABLE_FL)
281 27 : binode_flags |= BTRFS_INODE_IMMUTABLE;
282 : else
283 588 : binode_flags &= ~BTRFS_INODE_IMMUTABLE;
284 615 : if (fsflags & FS_APPEND_FL)
285 24 : binode_flags |= BTRFS_INODE_APPEND;
286 : else
287 591 : binode_flags &= ~BTRFS_INODE_APPEND;
288 615 : if (fsflags & FS_NODUMP_FL)
289 10 : binode_flags |= BTRFS_INODE_NODUMP;
290 : else
291 605 : binode_flags &= ~BTRFS_INODE_NODUMP;
292 615 : if (fsflags & FS_NOATIME_FL)
293 3 : binode_flags |= BTRFS_INODE_NOATIME;
294 : else
295 612 : binode_flags &= ~BTRFS_INODE_NOATIME;
296 :
297 : /* If coming from FS_IOC_FSSETXATTR then skip unconverted flags */
298 615 : if (!fa->flags_valid) {
299 : /* 1 item for the inode */
300 476 : trans = btrfs_start_transaction(root, 1);
301 476 : if (IS_ERR(trans))
302 2 : return PTR_ERR(trans);
303 474 : goto update_flags;
304 : }
305 :
306 139 : if (fsflags & FS_DIRSYNC_FL)
307 0 : binode_flags |= BTRFS_INODE_DIRSYNC;
308 : else
309 139 : binode_flags &= ~BTRFS_INODE_DIRSYNC;
310 139 : if (fsflags & FS_NOCOW_FL) {
311 49 : if (S_ISREG(inode->i_mode)) {
312 : /*
313 : * It's safe to turn csums off here, no extents exist.
314 : * Otherwise we want the flag to reflect the real COW
315 : * status of the file and will not set it.
316 : */
317 49 : if (inode->i_size == 0)
318 49 : binode_flags |= BTRFS_INODE_NODATACOW |
319 : BTRFS_INODE_NODATASUM;
320 : } else {
321 0 : binode_flags |= BTRFS_INODE_NODATACOW;
322 : }
323 : } else {
324 : /*
325 : * Revert back under same assumptions as above
326 : */
327 90 : if (S_ISREG(inode->i_mode)) {
328 80 : if (inode->i_size == 0)
329 66 : binode_flags &= ~(BTRFS_INODE_NODATACOW |
330 : BTRFS_INODE_NODATASUM);
331 : } else {
332 10 : binode_flags &= ~BTRFS_INODE_NODATACOW;
333 : }
334 : }
335 :
336 : /*
337 : * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
338 : * flag may be changed automatically if compression code won't make
339 : * things smaller.
340 : */
341 139 : if (fsflags & FS_NOCOMP_FL) {
342 0 : binode_flags &= ~BTRFS_INODE_COMPRESS;
343 0 : binode_flags |= BTRFS_INODE_NOCOMPRESS;
344 139 : } else if (fsflags & FS_COMPR_FL) {
345 :
346 19 : if (IS_SWAPFILE(inode))
347 : return -ETXTBSY;
348 :
349 19 : binode_flags |= BTRFS_INODE_COMPRESS;
350 19 : binode_flags &= ~BTRFS_INODE_NOCOMPRESS;
351 :
352 19 : comp = btrfs_compress_type2str(fs_info->compress_type);
353 19 : if (!comp || comp[0] == 0)
354 2 : comp = btrfs_compress_type2str(BTRFS_COMPRESS_ZLIB);
355 : } else {
356 120 : binode_flags &= ~(BTRFS_INODE_COMPRESS | BTRFS_INODE_NOCOMPRESS);
357 : }
358 :
359 : /*
360 : * 1 for inode item
361 : * 2 for properties
362 : */
363 139 : trans = btrfs_start_transaction(root, 3);
364 139 : if (IS_ERR(trans))
365 0 : return PTR_ERR(trans);
366 :
367 139 : if (comp) {
368 38 : ret = btrfs_set_prop(trans, inode, "btrfs.compression", comp,
369 : strlen(comp), 0);
370 19 : if (ret) {
371 0 : btrfs_abort_transaction(trans, ret);
372 0 : goto out_end_trans;
373 : }
374 : } else {
375 120 : ret = btrfs_set_prop(trans, inode, "btrfs.compression", NULL,
376 : 0, 0);
377 120 : if (ret && ret != -ENODATA) {
378 0 : btrfs_abort_transaction(trans, ret);
379 0 : goto out_end_trans;
380 : }
381 : }
382 :
383 120 : update_flags:
384 613 : binode->flags = binode_flags;
385 613 : btrfs_sync_inode_flags_to_i_flags(inode);
386 613 : inode_inc_iversion(inode);
387 613 : inode->i_ctime = current_time(inode);
388 613 : ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
389 :
390 613 : out_end_trans:
391 613 : btrfs_end_transaction(trans);
392 613 : return ret;
393 : }
394 :
395 : /*
396 : * Start exclusive operation @type, return true on success
397 : */
398 239 : bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
399 : enum btrfs_exclusive_operation type)
400 : {
401 239 : bool ret = false;
402 :
403 239 : spin_lock(&fs_info->super_lock);
404 239 : if (fs_info->exclusive_operation == BTRFS_EXCLOP_NONE) {
405 239 : fs_info->exclusive_operation = type;
406 239 : ret = true;
407 : }
408 239 : spin_unlock(&fs_info->super_lock);
409 :
410 239 : return ret;
411 : }
412 :
413 : /*
414 : * Conditionally allow to enter the exclusive operation in case it's compatible
415 : * with the running one. This must be paired with btrfs_exclop_start_unlock and
416 : * btrfs_exclop_finish.
417 : *
418 : * Compatibility:
419 : * - the same type is already running
420 : * - when trying to add a device and balance has been paused
421 : * - not BTRFS_EXCLOP_NONE - this is intentionally incompatible and the caller
422 : * must check the condition first that would allow none -> @type
423 : */
424 0 : bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,
425 : enum btrfs_exclusive_operation type)
426 : {
427 0 : spin_lock(&fs_info->super_lock);
428 0 : if (fs_info->exclusive_operation == type ||
429 0 : (fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED &&
430 : type == BTRFS_EXCLOP_DEV_ADD))
431 : return true;
432 :
433 0 : spin_unlock(&fs_info->super_lock);
434 0 : return false;
435 : }
436 :
437 0 : void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info)
438 : {
439 0 : spin_unlock(&fs_info->super_lock);
440 0 : }
441 :
442 239 : void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)
443 : {
444 239 : spin_lock(&fs_info->super_lock);
445 239 : WRITE_ONCE(fs_info->exclusive_operation, BTRFS_EXCLOP_NONE);
446 239 : spin_unlock(&fs_info->super_lock);
447 239 : sysfs_notify(&fs_info->fs_devices->fsid_kobj, NULL, "exclusive_operation");
448 239 : }
449 :
450 0 : void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,
451 : enum btrfs_exclusive_operation op)
452 : {
453 0 : switch (op) {
454 0 : case BTRFS_EXCLOP_BALANCE_PAUSED:
455 0 : spin_lock(&fs_info->super_lock);
456 0 : ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE ||
457 : fs_info->exclusive_operation == BTRFS_EXCLOP_DEV_ADD ||
458 : fs_info->exclusive_operation == BTRFS_EXCLOP_NONE ||
459 : fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);
460 0 : fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE_PAUSED;
461 0 : spin_unlock(&fs_info->super_lock);
462 : break;
463 0 : case BTRFS_EXCLOP_BALANCE:
464 0 : spin_lock(&fs_info->super_lock);
465 0 : ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);
466 0 : fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE;
467 0 : spin_unlock(&fs_info->super_lock);
468 : break;
469 0 : default:
470 0 : btrfs_warn(fs_info,
471 : "invalid exclop balance operation %d requested", op);
472 : }
473 0 : }
474 :
475 : static int btrfs_ioctl_getversion(struct inode *inode, int __user *arg)
476 : {
477 0 : return put_user(inode->i_generation, arg);
478 : }
479 :
480 851 : static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,
481 : void __user *arg)
482 : {
483 851 : struct btrfs_device *device;
484 851 : struct fstrim_range range;
485 851 : u64 minlen = ULLONG_MAX;
486 851 : u64 num_devices = 0;
487 851 : int ret;
488 :
489 851 : if (!capable(CAP_SYS_ADMIN))
490 : return -EPERM;
491 :
492 : /*
493 : * btrfs_trim_block_group() depends on space cache, which is not
494 : * available in zoned filesystem. So, disallow fitrim on a zoned
495 : * filesystem for now.
496 : */
497 851 : if (btrfs_is_zoned(fs_info))
498 : return -EOPNOTSUPP;
499 :
500 : /*
501 : * If the fs is mounted with nologreplay, which requires it to be
502 : * mounted in RO mode as well, we can not allow discard on free space
503 : * inside block groups, because log trees refer to extents that are not
504 : * pinned in a block group's free space cache (pinning the extents is
505 : * precisely the first phase of replaying a log tree).
506 : */
507 851 : if (btrfs_test_opt(fs_info, NOLOGREPLAY))
508 : return -EROFS;
509 :
510 850 : rcu_read_lock();
511 1700 : list_for_each_entry_rcu(device, &fs_info->fs_devices->devices,
512 : dev_list) {
513 850 : if (!device->bdev || !bdev_max_discard_sectors(device->bdev))
514 0 : continue;
515 850 : num_devices++;
516 850 : minlen = min_t(u64, bdev_discard_granularity(device->bdev),
517 : minlen);
518 : }
519 850 : rcu_read_unlock();
520 :
521 850 : if (!num_devices)
522 : return -EOPNOTSUPP;
523 850 : if (copy_from_user(&range, arg, sizeof(range)))
524 : return -EFAULT;
525 :
526 : /*
527 : * NOTE: Don't truncate the range using super->total_bytes. Bytenr of
528 : * block group is in the logical address space, which can be any
529 : * sectorsize aligned bytenr in the range [0, U64_MAX].
530 : */
531 850 : if (range.len < fs_info->sb->s_blocksize)
532 : return -EINVAL;
533 :
534 848 : range.minlen = max(range.minlen, minlen);
535 848 : ret = btrfs_trim_fs(fs_info, &range);
536 848 : if (ret < 0)
537 : return ret;
538 :
539 842 : if (copy_to_user(arg, &range, sizeof(range)))
540 0 : return -EFAULT;
541 :
542 : return 0;
543 : }
544 :
545 10033 : int __pure btrfs_is_empty_uuid(u8 *uuid)
546 : {
547 10072 : int i;
548 :
549 127029 : for (i = 0; i < BTRFS_UUID_SIZE; i++) {
550 119743 : if (uuid[i])
551 : return 0;
552 : }
553 : return 1;
554 : }
555 :
556 : /*
557 : * Calculate the number of transaction items to reserve for creating a subvolume
558 : * or snapshot, not including the inode, directory entries, or parent directory.
559 : */
560 : static unsigned int create_subvol_num_items(struct btrfs_qgroup_inherit *inherit)
561 : {
562 : /*
563 : * 1 to add root block
564 : * 1 to add root item
565 : * 1 to add root ref
566 : * 1 to add root backref
567 : * 1 to add UUID item
568 : * 1 to add qgroup info
569 : * 1 to add qgroup limit
570 : *
571 : * Ideally the last two would only be accounted if qgroups are enabled,
572 : * but that can change between now and the time we would insert them.
573 : */
574 1278 : unsigned int num_items = 7;
575 :
576 1278 : if (inherit) {
577 : /* 2 to add qgroup relations for each inherited qgroup */
578 13 : num_items += 2 * inherit->num_qgroups;
579 : }
580 1278 : return num_items;
581 : }
582 :
583 252 : static noinline int create_subvol(struct mnt_idmap *idmap,
584 : struct inode *dir, struct dentry *dentry,
585 : struct btrfs_qgroup_inherit *inherit)
586 : {
587 252 : struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
588 252 : struct btrfs_trans_handle *trans;
589 252 : struct btrfs_key key;
590 252 : struct btrfs_root_item *root_item;
591 252 : struct btrfs_inode_item *inode_item;
592 252 : struct extent_buffer *leaf;
593 252 : struct btrfs_root *root = BTRFS_I(dir)->root;
594 252 : struct btrfs_root *new_root;
595 252 : struct btrfs_block_rsv block_rsv;
596 252 : struct timespec64 cur_time = current_time(dir);
597 252 : struct btrfs_new_inode_args new_inode_args = {
598 : .dir = dir,
599 : .dentry = dentry,
600 : .subvol = true,
601 : };
602 252 : unsigned int trans_num_items;
603 252 : int ret;
604 252 : dev_t anon_dev;
605 252 : u64 objectid;
606 :
607 252 : root_item = kzalloc(sizeof(*root_item), GFP_KERNEL);
608 252 : if (!root_item)
609 : return -ENOMEM;
610 :
611 252 : ret = btrfs_get_free_objectid(fs_info->tree_root, &objectid);
612 252 : if (ret)
613 0 : goto out_root_item;
614 :
615 : /*
616 : * Don't create subvolume whose level is not zero. Or qgroup will be
617 : * screwed up since it assumes subvolume qgroup's level to be 0.
618 : */
619 252 : if (btrfs_qgroup_level(objectid)) {
620 0 : ret = -ENOSPC;
621 0 : goto out_root_item;
622 : }
623 :
624 252 : ret = get_anon_bdev(&anon_dev);
625 252 : if (ret < 0)
626 0 : goto out_root_item;
627 :
628 252 : new_inode_args.inode = btrfs_new_subvol_inode(idmap, dir);
629 252 : if (!new_inode_args.inode) {
630 0 : ret = -ENOMEM;
631 0 : goto out_anon_dev;
632 : }
633 252 : ret = btrfs_new_inode_prepare(&new_inode_args, &trans_num_items);
634 252 : if (ret)
635 0 : goto out_inode;
636 252 : trans_num_items += create_subvol_num_items(inherit);
637 :
638 252 : btrfs_init_block_rsv(&block_rsv, BTRFS_BLOCK_RSV_TEMP);
639 252 : ret = btrfs_subvolume_reserve_metadata(root, &block_rsv,
640 : trans_num_items, false);
641 252 : if (ret)
642 0 : goto out_new_inode_args;
643 :
644 252 : trans = btrfs_start_transaction(root, 0);
645 252 : if (IS_ERR(trans)) {
646 0 : ret = PTR_ERR(trans);
647 0 : btrfs_subvolume_release_metadata(root, &block_rsv);
648 0 : goto out_new_inode_args;
649 : }
650 252 : trans->block_rsv = &block_rsv;
651 252 : trans->bytes_reserved = block_rsv.size;
652 : /* Tree log can't currently deal with an inode which is a new root. */
653 252 : btrfs_set_log_full_commit(trans);
654 :
655 252 : ret = btrfs_qgroup_inherit(trans, 0, objectid, inherit);
656 252 : if (ret)
657 0 : goto out;
658 :
659 252 : leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,
660 : BTRFS_NESTING_NORMAL);
661 252 : if (IS_ERR(leaf)) {
662 0 : ret = PTR_ERR(leaf);
663 0 : goto out;
664 : }
665 :
666 252 : btrfs_mark_buffer_dirty(leaf);
667 :
668 252 : inode_item = &root_item->inode;
669 252 : btrfs_set_stack_inode_generation(inode_item, 1);
670 252 : btrfs_set_stack_inode_size(inode_item, 3);
671 252 : btrfs_set_stack_inode_nlink(inode_item, 1);
672 252 : btrfs_set_stack_inode_nbytes(inode_item,
673 252 : fs_info->nodesize);
674 252 : btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
675 :
676 252 : btrfs_set_root_flags(root_item, 0);
677 252 : btrfs_set_root_limit(root_item, 0);
678 252 : btrfs_set_stack_inode_flags(inode_item, BTRFS_INODE_ROOT_ITEM_INIT);
679 :
680 252 : btrfs_set_root_bytenr(root_item, leaf->start);
681 252 : btrfs_set_root_generation(root_item, trans->transid);
682 252 : btrfs_set_root_level(root_item, 0);
683 252 : btrfs_set_root_refs(root_item, 1);
684 252 : btrfs_set_root_used(root_item, leaf->len);
685 252 : btrfs_set_root_last_snapshot(root_item, 0);
686 :
687 252 : btrfs_set_root_generation_v2(root_item,
688 : btrfs_root_generation(root_item));
689 252 : generate_random_guid(root_item->uuid);
690 252 : btrfs_set_stack_timespec_sec(&root_item->otime, cur_time.tv_sec);
691 252 : btrfs_set_stack_timespec_nsec(&root_item->otime, cur_time.tv_nsec);
692 252 : root_item->ctime = root_item->otime;
693 252 : btrfs_set_root_ctransid(root_item, trans->transid);
694 252 : btrfs_set_root_otransid(root_item, trans->transid);
695 :
696 252 : btrfs_tree_unlock(leaf);
697 :
698 252 : btrfs_set_root_dirid(root_item, BTRFS_FIRST_FREE_OBJECTID);
699 :
700 252 : key.objectid = objectid;
701 252 : key.offset = 0;
702 252 : key.type = BTRFS_ROOT_ITEM_KEY;
703 252 : ret = btrfs_insert_root(trans, fs_info->tree_root, &key,
704 : root_item);
705 252 : if (ret) {
706 : /*
707 : * Since we don't abort the transaction in this case, free the
708 : * tree block so that we don't leak space and leave the
709 : * filesystem in an inconsistent state (an extent item in the
710 : * extent tree with a backreference for a root that does not
711 : * exists).
712 : */
713 0 : btrfs_tree_lock(leaf);
714 0 : btrfs_clear_buffer_dirty(trans, leaf);
715 0 : btrfs_tree_unlock(leaf);
716 0 : btrfs_free_tree_block(trans, objectid, leaf, 0, 1);
717 0 : free_extent_buffer(leaf);
718 0 : goto out;
719 : }
720 :
721 252 : free_extent_buffer(leaf);
722 252 : leaf = NULL;
723 :
724 252 : new_root = btrfs_get_new_fs_root(fs_info, objectid, anon_dev);
725 252 : if (IS_ERR(new_root)) {
726 0 : ret = PTR_ERR(new_root);
727 0 : btrfs_abort_transaction(trans, ret);
728 0 : goto out;
729 : }
730 : /* anon_dev is owned by new_root now. */
731 252 : anon_dev = 0;
732 252 : BTRFS_I(new_inode_args.inode)->root = new_root;
733 : /* ... and new_root is owned by new_inode_args.inode now. */
734 :
735 252 : ret = btrfs_record_root_in_trans(trans, new_root);
736 252 : if (ret) {
737 0 : btrfs_abort_transaction(trans, ret);
738 0 : goto out;
739 : }
740 :
741 252 : ret = btrfs_uuid_tree_add(trans, root_item->uuid,
742 : BTRFS_UUID_KEY_SUBVOL, objectid);
743 252 : if (ret) {
744 0 : btrfs_abort_transaction(trans, ret);
745 0 : goto out;
746 : }
747 :
748 252 : ret = btrfs_create_new_inode(trans, &new_inode_args);
749 252 : if (ret) {
750 0 : btrfs_abort_transaction(trans, ret);
751 0 : goto out;
752 : }
753 :
754 252 : d_instantiate_new(dentry, new_inode_args.inode);
755 252 : new_inode_args.inode = NULL;
756 :
757 252 : out:
758 252 : trans->block_rsv = NULL;
759 252 : trans->bytes_reserved = 0;
760 252 : btrfs_subvolume_release_metadata(root, &block_rsv);
761 :
762 252 : btrfs_end_transaction(trans);
763 252 : out_new_inode_args:
764 252 : btrfs_new_inode_args_destroy(&new_inode_args);
765 252 : out_inode:
766 252 : iput(new_inode_args.inode);
767 252 : out_anon_dev:
768 252 : if (anon_dev)
769 0 : free_anon_bdev(anon_dev);
770 252 : out_root_item:
771 252 : kfree(root_item);
772 252 : return ret;
773 : }
774 :
775 1027 : static int create_snapshot(struct btrfs_root *root, struct inode *dir,
776 : struct dentry *dentry, bool readonly,
777 : struct btrfs_qgroup_inherit *inherit)
778 : {
779 1027 : struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
780 1027 : struct inode *inode;
781 1027 : struct btrfs_pending_snapshot *pending_snapshot;
782 1027 : unsigned int trans_num_items;
783 1027 : struct btrfs_trans_handle *trans;
784 1027 : int ret;
785 :
786 : /* We do not support snapshotting right now. */
787 1027 : if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
788 0 : btrfs_warn(fs_info,
789 : "extent tree v2 doesn't support snapshotting yet");
790 0 : return -EOPNOTSUPP;
791 : }
792 :
793 1027 : if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
794 : return -EINVAL;
795 :
796 1027 : if (atomic_read(&root->nr_swapfiles)) {
797 1 : btrfs_warn(fs_info,
798 : "cannot snapshot subvolume with active swapfile");
799 1 : return -ETXTBSY;
800 : }
801 :
802 1026 : pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_KERNEL);
803 1025 : if (!pending_snapshot)
804 : return -ENOMEM;
805 :
806 1025 : ret = get_anon_bdev(&pending_snapshot->anon_dev);
807 1026 : if (ret < 0)
808 0 : goto free_pending;
809 1026 : pending_snapshot->root_item = kzalloc(sizeof(struct btrfs_root_item),
810 : GFP_KERNEL);
811 1026 : pending_snapshot->path = btrfs_alloc_path();
812 1026 : if (!pending_snapshot->root_item || !pending_snapshot->path) {
813 0 : ret = -ENOMEM;
814 0 : goto free_pending;
815 : }
816 :
817 1026 : btrfs_init_block_rsv(&pending_snapshot->block_rsv,
818 : BTRFS_BLOCK_RSV_TEMP);
819 : /*
820 : * 1 to add dir item
821 : * 1 to add dir index
822 : * 1 to update parent inode item
823 : */
824 1026 : trans_num_items = create_subvol_num_items(inherit) + 3;
825 1026 : ret = btrfs_subvolume_reserve_metadata(BTRFS_I(dir)->root,
826 : &pending_snapshot->block_rsv,
827 : trans_num_items, false);
828 1026 : if (ret)
829 0 : goto free_pending;
830 :
831 1026 : pending_snapshot->dentry = dentry;
832 1026 : pending_snapshot->root = root;
833 1026 : pending_snapshot->readonly = readonly;
834 1026 : pending_snapshot->dir = dir;
835 1026 : pending_snapshot->inherit = inherit;
836 :
837 1026 : trans = btrfs_start_transaction(root, 0);
838 1026 : if (IS_ERR(trans)) {
839 0 : ret = PTR_ERR(trans);
840 0 : goto fail;
841 : }
842 :
843 1026 : trans->pending_snapshot = pending_snapshot;
844 :
845 1026 : ret = btrfs_commit_transaction(trans);
846 1026 : if (ret)
847 0 : goto fail;
848 :
849 1026 : ret = pending_snapshot->error;
850 1026 : if (ret)
851 0 : goto fail;
852 :
853 1026 : ret = btrfs_orphan_cleanup(pending_snapshot->snap);
854 1026 : if (ret)
855 0 : goto fail;
856 :
857 1026 : inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);
858 1026 : if (IS_ERR(inode)) {
859 0 : ret = PTR_ERR(inode);
860 0 : goto fail;
861 : }
862 :
863 1026 : d_instantiate(dentry, inode);
864 1026 : ret = 0;
865 1026 : pending_snapshot->anon_dev = 0;
866 0 : fail:
867 : /* Prevent double freeing of anon_dev */
868 1026 : if (ret && pending_snapshot->snap)
869 0 : pending_snapshot->snap->anon_dev = 0;
870 1026 : btrfs_put_root(pending_snapshot->snap);
871 1026 : btrfs_subvolume_release_metadata(root, &pending_snapshot->block_rsv);
872 1026 : free_pending:
873 1026 : if (pending_snapshot->anon_dev)
874 0 : free_anon_bdev(pending_snapshot->anon_dev);
875 1026 : kfree(pending_snapshot->root_item);
876 1026 : btrfs_free_path(pending_snapshot->path);
877 1026 : kfree(pending_snapshot);
878 :
879 1026 : return ret;
880 : }
881 :
882 : /* copy of may_delete in fs/namei.c()
883 : * Check whether we can remove a link victim from directory dir, check
884 : * whether the type of victim is right.
885 : * 1. We can't do it if dir is read-only (done in permission())
886 : * 2. We should have write and exec permissions on dir
887 : * 3. We can't remove anything from append-only dir
888 : * 4. We can't do anything with immutable dir (done in permission())
889 : * 5. If the sticky bit on dir is set we should either
890 : * a. be owner of dir, or
891 : * b. be owner of victim, or
892 : * c. have CAP_FOWNER capability
893 : * 6. If the victim is append-only or immutable we can't do anything with
894 : * links pointing to it.
895 : * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
896 : * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
897 : * 9. We can't remove a root or mountpoint.
898 : * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
899 : * nfs_async_unlink().
900 : */
901 :
902 158 : static int btrfs_may_delete(struct mnt_idmap *idmap,
903 : struct inode *dir, struct dentry *victim, int isdir)
904 : {
905 158 : int error;
906 :
907 158 : if (d_really_is_negative(victim))
908 : return -ENOENT;
909 :
910 158 : BUG_ON(d_inode(victim->d_parent) != dir);
911 158 : audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
912 :
913 158 : error = inode_permission(idmap, dir, MAY_WRITE | MAY_EXEC);
914 158 : if (error)
915 : return error;
916 158 : if (IS_APPEND(dir))
917 : return -EPERM;
918 158 : if (check_sticky(idmap, dir, d_inode(victim)) ||
919 158 : IS_APPEND(d_inode(victim)) || IS_IMMUTABLE(d_inode(victim)) ||
920 158 : IS_SWAPFILE(d_inode(victim)))
921 : return -EPERM;
922 158 : if (isdir) {
923 158 : if (!d_is_dir(victim))
924 : return -ENOTDIR;
925 158 : if (IS_ROOT(victim))
926 : return -EBUSY;
927 0 : } else if (d_is_dir(victim))
928 : return -EISDIR;
929 158 : if (IS_DEADDIR(dir))
930 : return -ENOENT;
931 158 : if (victim->d_flags & DCACHE_NFSFS_RENAMED)
932 0 : return -EBUSY;
933 : return 0;
934 : }
935 :
936 : /* copy of may_create in fs/namei.c() */
937 1285 : static inline int btrfs_may_create(struct mnt_idmap *idmap,
938 : struct inode *dir, struct dentry *child)
939 : {
940 1285 : if (d_really_is_positive(child))
941 : return -EEXIST;
942 1285 : if (IS_DEADDIR(dir))
943 : return -ENOENT;
944 1285 : if (!fsuidgid_has_mapping(dir->i_sb, idmap))
945 : return -EOVERFLOW;
946 1279 : return inode_permission(idmap, dir, MAY_WRITE | MAY_EXEC);
947 : }
948 :
949 : /*
950 : * Create a new subvolume below @parent. This is largely modeled after
951 : * sys_mkdirat and vfs_mkdir, but we only do a single component lookup
952 : * inside this filesystem so it's quite a bit simpler.
953 : */
954 1285 : static noinline int btrfs_mksubvol(const struct path *parent,
955 : struct mnt_idmap *idmap,
956 : const char *name, int namelen,
957 : struct btrfs_root *snap_src,
958 : bool readonly,
959 : struct btrfs_qgroup_inherit *inherit)
960 : {
961 1285 : struct inode *dir = d_inode(parent->dentry);
962 1285 : struct btrfs_fs_info *fs_info = btrfs_sb(dir->i_sb);
963 1285 : struct dentry *dentry;
964 1285 : struct fscrypt_str name_str = FSTR_INIT((char *)name, namelen);
965 1285 : int error;
966 :
967 1285 : error = down_write_killable_nested(&dir->i_rwsem, I_MUTEX_PARENT);
968 1285 : if (error == -EINTR)
969 : return error;
970 :
971 1285 : dentry = lookup_one(idmap, name, parent->dentry, namelen);
972 1285 : error = PTR_ERR(dentry);
973 1285 : if (IS_ERR(dentry))
974 0 : goto out_unlock;
975 :
976 1285 : error = btrfs_may_create(idmap, dir, dentry);
977 1285 : if (error)
978 6 : goto out_dput;
979 :
980 : /*
981 : * even if this name doesn't exist, we may get hash collisions.
982 : * check for them now when we can safely fail
983 : */
984 1279 : error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
985 1279 : dir->i_ino, &name_str);
986 1279 : if (error)
987 0 : goto out_dput;
988 :
989 1279 : down_read(&fs_info->subvol_sem);
990 :
991 1279 : if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
992 0 : goto out_up_read;
993 :
994 1279 : if (snap_src)
995 1027 : error = create_snapshot(snap_src, dir, dentry, readonly, inherit);
996 : else
997 252 : error = create_subvol(idmap, dir, dentry, inherit);
998 :
999 1279 : if (!error)
1000 1278 : fsnotify_mkdir(dir, dentry);
1001 1 : out_up_read:
1002 1279 : up_read(&fs_info->subvol_sem);
1003 1285 : out_dput:
1004 1285 : dput(dentry);
1005 1285 : out_unlock:
1006 1285 : btrfs_inode_unlock(BTRFS_I(dir), 0);
1007 1285 : return error;
1008 : }
1009 :
1010 1029 : static noinline int btrfs_mksnapshot(const struct path *parent,
1011 : struct mnt_idmap *idmap,
1012 : const char *name, int namelen,
1013 : struct btrfs_root *root,
1014 : bool readonly,
1015 : struct btrfs_qgroup_inherit *inherit)
1016 : {
1017 1029 : int ret;
1018 1029 : bool snapshot_force_cow = false;
1019 :
1020 : /*
1021 : * Force new buffered writes to reserve space even when NOCOW is
1022 : * possible. This is to avoid later writeback (running dealloc) to
1023 : * fallback to COW mode and unexpectedly fail with ENOSPC.
1024 : */
1025 1029 : btrfs_drew_read_lock(&root->snapshot_lock);
1026 :
1027 1029 : ret = btrfs_start_delalloc_snapshot(root, false);
1028 1029 : if (ret)
1029 0 : goto out;
1030 :
1031 : /*
1032 : * All previous writes have started writeback in NOCOW mode, so now
1033 : * we force future writes to fallback to COW mode during snapshot
1034 : * creation.
1035 : */
1036 1029 : atomic_inc(&root->snapshot_force_cow);
1037 1029 : snapshot_force_cow = true;
1038 :
1039 1029 : btrfs_wait_ordered_extents(root, U64_MAX, 0, (u64)-1);
1040 :
1041 1029 : ret = btrfs_mksubvol(parent, idmap, name, namelen,
1042 : root, readonly, inherit);
1043 : out:
1044 0 : if (snapshot_force_cow)
1045 1029 : atomic_dec(&root->snapshot_force_cow);
1046 1029 : btrfs_drew_read_unlock(&root->snapshot_lock);
1047 1029 : return ret;
1048 : }
1049 :
1050 : /*
1051 : * Try to start exclusive operation @type or cancel it if it's running.
1052 : *
1053 : * Return:
1054 : * 0 - normal mode, newly claimed op started
1055 : * >0 - normal mode, something else is running,
1056 : * return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS to user space
1057 : * ECANCELED - cancel mode, successful cancel
1058 : * ENOTCONN - cancel mode, operation not running anymore
1059 : */
1060 5 : static int exclop_start_or_cancel_reloc(struct btrfs_fs_info *fs_info,
1061 : enum btrfs_exclusive_operation type, bool cancel)
1062 : {
1063 5 : if (!cancel) {
1064 : /* Start normal op */
1065 5 : if (!btrfs_exclop_start(fs_info, type))
1066 : return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
1067 : /* Exclusive operation is now claimed */
1068 5 : return 0;
1069 : }
1070 :
1071 : /* Cancel running op */
1072 0 : if (btrfs_exclop_start_try_lock(fs_info, type)) {
1073 : /*
1074 : * This blocks any exclop finish from setting it to NONE, so we
1075 : * request cancellation. Either it runs and we will wait for it,
1076 : * or it has finished and no waiting will happen.
1077 : */
1078 0 : atomic_inc(&fs_info->reloc_cancel_req);
1079 0 : btrfs_exclop_start_unlock(fs_info);
1080 :
1081 0 : if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags))
1082 0 : wait_on_bit(&fs_info->flags, BTRFS_FS_RELOC_RUNNING,
1083 : TASK_INTERRUPTIBLE);
1084 :
1085 0 : return -ECANCELED;
1086 : }
1087 :
1088 : /* Something else is running or none */
1089 : return -ENOTCONN;
1090 : }
1091 :
1092 4 : static noinline int btrfs_ioctl_resize(struct file *file,
1093 : void __user *arg)
1094 : {
1095 4 : BTRFS_DEV_LOOKUP_ARGS(args);
1096 4 : struct inode *inode = file_inode(file);
1097 4 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1098 4 : u64 new_size;
1099 4 : u64 old_size;
1100 4 : u64 devid = 1;
1101 4 : struct btrfs_root *root = BTRFS_I(inode)->root;
1102 4 : struct btrfs_ioctl_vol_args *vol_args;
1103 4 : struct btrfs_trans_handle *trans;
1104 4 : struct btrfs_device *device = NULL;
1105 4 : char *sizestr;
1106 4 : char *retptr;
1107 4 : char *devstr = NULL;
1108 4 : int ret = 0;
1109 4 : int mod = 0;
1110 4 : bool cancel;
1111 :
1112 4 : if (!capable(CAP_SYS_ADMIN))
1113 : return -EPERM;
1114 :
1115 4 : ret = mnt_want_write_file(file);
1116 4 : if (ret)
1117 : return ret;
1118 :
1119 : /*
1120 : * Read the arguments before checking exclusivity to be able to
1121 : * distinguish regular resize and cancel
1122 : */
1123 4 : vol_args = memdup_user(arg, sizeof(*vol_args));
1124 4 : if (IS_ERR(vol_args)) {
1125 0 : ret = PTR_ERR(vol_args);
1126 0 : goto out_drop;
1127 : }
1128 4 : vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
1129 4 : sizestr = vol_args->name;
1130 4 : cancel = (strcmp("cancel", sizestr) == 0);
1131 4 : ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_RESIZE, cancel);
1132 4 : if (ret)
1133 0 : goto out_free;
1134 : /* Exclusive operation is now claimed */
1135 :
1136 4 : devstr = strchr(sizestr, ':');
1137 4 : if (devstr) {
1138 1 : sizestr = devstr + 1;
1139 1 : *devstr = '\0';
1140 1 : devstr = vol_args->name;
1141 1 : ret = kstrtoull(devstr, 10, &devid);
1142 1 : if (ret)
1143 0 : goto out_finish;
1144 1 : if (!devid) {
1145 0 : ret = -EINVAL;
1146 0 : goto out_finish;
1147 : }
1148 1 : btrfs_info(fs_info, "resizing devid %llu", devid);
1149 : }
1150 :
1151 4 : args.devid = devid;
1152 4 : device = btrfs_find_device(fs_info->fs_devices, &args);
1153 4 : if (!device) {
1154 0 : btrfs_info(fs_info, "resizer unable to find device %llu",
1155 : devid);
1156 0 : ret = -ENODEV;
1157 0 : goto out_finish;
1158 : }
1159 :
1160 4 : if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) {
1161 0 : btrfs_info(fs_info,
1162 : "resizer unable to apply on readonly device %llu",
1163 : devid);
1164 0 : ret = -EPERM;
1165 0 : goto out_finish;
1166 : }
1167 :
1168 4 : if (!strcmp(sizestr, "max"))
1169 0 : new_size = bdev_nr_bytes(device->bdev);
1170 : else {
1171 4 : if (sizestr[0] == '-') {
1172 1 : mod = -1;
1173 1 : sizestr++;
1174 3 : } else if (sizestr[0] == '+') {
1175 0 : mod = 1;
1176 0 : sizestr++;
1177 : }
1178 4 : new_size = memparse(sizestr, &retptr);
1179 4 : if (*retptr != '\0' || new_size == 0) {
1180 0 : ret = -EINVAL;
1181 0 : goto out_finish;
1182 : }
1183 : }
1184 :
1185 8 : if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) {
1186 0 : ret = -EPERM;
1187 0 : goto out_finish;
1188 : }
1189 :
1190 4 : old_size = btrfs_device_get_total_bytes(device);
1191 :
1192 4 : if (mod < 0) {
1193 1 : if (new_size > old_size) {
1194 0 : ret = -EINVAL;
1195 0 : goto out_finish;
1196 : }
1197 1 : new_size = old_size - new_size;
1198 3 : } else if (mod > 0) {
1199 0 : if (new_size > ULLONG_MAX - old_size) {
1200 0 : ret = -ERANGE;
1201 0 : goto out_finish;
1202 : }
1203 0 : new_size = old_size + new_size;
1204 : }
1205 :
1206 4 : if (new_size < SZ_256M) {
1207 0 : ret = -EINVAL;
1208 0 : goto out_finish;
1209 : }
1210 4 : if (new_size > bdev_nr_bytes(device->bdev)) {
1211 0 : ret = -EFBIG;
1212 0 : goto out_finish;
1213 : }
1214 :
1215 4 : new_size = round_down(new_size, fs_info->sectorsize);
1216 :
1217 4 : if (new_size > old_size) {
1218 1 : trans = btrfs_start_transaction(root, 0);
1219 1 : if (IS_ERR(trans)) {
1220 0 : ret = PTR_ERR(trans);
1221 0 : goto out_finish;
1222 : }
1223 1 : ret = btrfs_grow_device(trans, device, new_size);
1224 1 : btrfs_commit_transaction(trans);
1225 3 : } else if (new_size < old_size) {
1226 3 : ret = btrfs_shrink_device(device, new_size);
1227 : } /* equal, nothing need to do */
1228 :
1229 4 : if (ret == 0 && new_size != old_size)
1230 3 : btrfs_info_in_rcu(fs_info,
1231 : "resize device %s (devid %llu) from %llu to %llu",
1232 : btrfs_dev_name(device), device->devid,
1233 : old_size, new_size);
1234 1 : out_finish:
1235 4 : btrfs_exclop_finish(fs_info);
1236 4 : out_free:
1237 4 : kfree(vol_args);
1238 4 : out_drop:
1239 4 : mnt_drop_write_file(file);
1240 4 : return ret;
1241 : }
1242 :
1243 1289 : static noinline int __btrfs_ioctl_snap_create(struct file *file,
1244 : struct mnt_idmap *idmap,
1245 : const char *name, unsigned long fd, int subvol,
1246 : bool readonly,
1247 : struct btrfs_qgroup_inherit *inherit)
1248 : {
1249 1289 : int namelen;
1250 1289 : int ret = 0;
1251 :
1252 1289 : if (!S_ISDIR(file_inode(file)->i_mode))
1253 : return -ENOTDIR;
1254 :
1255 1289 : ret = mnt_want_write_file(file);
1256 1289 : if (ret)
1257 0 : goto out;
1258 :
1259 1289 : namelen = strlen(name);
1260 1289 : if (strchr(name, '/')) {
1261 0 : ret = -EINVAL;
1262 0 : goto out_drop_write;
1263 : }
1264 :
1265 1289 : if (name[0] == '.' &&
1266 0 : (namelen == 1 || (name[1] == '.' && namelen == 2))) {
1267 0 : ret = -EEXIST;
1268 0 : goto out_drop_write;
1269 : }
1270 :
1271 1289 : if (subvol) {
1272 256 : ret = btrfs_mksubvol(&file->f_path, idmap, name,
1273 : namelen, NULL, readonly, inherit);
1274 : } else {
1275 1033 : struct fd src = fdget(fd);
1276 1033 : struct inode *src_inode;
1277 1033 : if (!src.file) {
1278 0 : ret = -EINVAL;
1279 0 : goto out_drop_write;
1280 : }
1281 :
1282 1033 : src_inode = file_inode(src.file);
1283 1033 : if (src_inode->i_sb != file_inode(file)->i_sb) {
1284 0 : btrfs_info(BTRFS_I(file_inode(file))->root->fs_info,
1285 : "Snapshot src from another FS");
1286 0 : ret = -EXDEV;
1287 1033 : } else if (!inode_owner_or_capable(idmap, src_inode)) {
1288 : /*
1289 : * Subvolume creation is not restricted, but snapshots
1290 : * are limited to own subvolumes only
1291 : */
1292 : ret = -EPERM;
1293 : } else {
1294 1029 : ret = btrfs_mksnapshot(&file->f_path, idmap,
1295 : name, namelen,
1296 : BTRFS_I(src_inode)->root,
1297 : readonly, inherit);
1298 : }
1299 1033 : fdput(src);
1300 : }
1301 1289 : out_drop_write:
1302 1289 : mnt_drop_write_file(file);
1303 : out:
1304 : return ret;
1305 : }
1306 :
1307 213 : static noinline int btrfs_ioctl_snap_create(struct file *file,
1308 : void __user *arg, int subvol)
1309 : {
1310 213 : struct btrfs_ioctl_vol_args *vol_args;
1311 213 : int ret;
1312 :
1313 213 : if (!S_ISDIR(file_inode(file)->i_mode))
1314 : return -ENOTDIR;
1315 :
1316 213 : vol_args = memdup_user(arg, sizeof(*vol_args));
1317 213 : if (IS_ERR(vol_args))
1318 0 : return PTR_ERR(vol_args);
1319 213 : vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
1320 :
1321 213 : ret = __btrfs_ioctl_snap_create(file, file_mnt_idmap(file),
1322 213 : vol_args->name, vol_args->fd, subvol,
1323 : false, NULL);
1324 :
1325 213 : kfree(vol_args);
1326 213 : return ret;
1327 : }
1328 :
1329 1076 : static noinline int btrfs_ioctl_snap_create_v2(struct file *file,
1330 : void __user *arg, int subvol)
1331 : {
1332 1076 : struct btrfs_ioctl_vol_args_v2 *vol_args;
1333 1076 : int ret;
1334 1076 : bool readonly = false;
1335 1076 : struct btrfs_qgroup_inherit *inherit = NULL;
1336 :
1337 1076 : if (!S_ISDIR(file_inode(file)->i_mode))
1338 : return -ENOTDIR;
1339 :
1340 1076 : vol_args = memdup_user(arg, sizeof(*vol_args));
1341 1076 : if (IS_ERR(vol_args))
1342 0 : return PTR_ERR(vol_args);
1343 1076 : vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
1344 :
1345 1076 : if (vol_args->flags & ~BTRFS_SUBVOL_CREATE_ARGS_MASK) {
1346 0 : ret = -EOPNOTSUPP;
1347 0 : goto free_args;
1348 : }
1349 :
1350 1076 : if (vol_args->flags & BTRFS_SUBVOL_RDONLY)
1351 741 : readonly = true;
1352 1076 : if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
1353 13 : u64 nums;
1354 :
1355 13 : if (vol_args->size < sizeof(*inherit) ||
1356 : vol_args->size > PAGE_SIZE) {
1357 0 : ret = -EINVAL;
1358 0 : goto free_args;
1359 : }
1360 13 : inherit = memdup_user(vol_args->qgroup_inherit, vol_args->size);
1361 13 : if (IS_ERR(inherit)) {
1362 0 : ret = PTR_ERR(inherit);
1363 0 : goto free_args;
1364 : }
1365 :
1366 13 : if (inherit->num_qgroups > PAGE_SIZE ||
1367 13 : inherit->num_ref_copies > PAGE_SIZE ||
1368 13 : inherit->num_excl_copies > PAGE_SIZE) {
1369 0 : ret = -EINVAL;
1370 0 : goto free_inherit;
1371 : }
1372 :
1373 13 : nums = inherit->num_qgroups + 2 * inherit->num_ref_copies +
1374 : 2 * inherit->num_excl_copies;
1375 13 : if (vol_args->size != struct_size(inherit, qgroups, nums)) {
1376 0 : ret = -EINVAL;
1377 0 : goto free_inherit;
1378 : }
1379 : }
1380 :
1381 1076 : ret = __btrfs_ioctl_snap_create(file, file_mnt_idmap(file),
1382 1076 : vol_args->name, vol_args->fd, subvol,
1383 : readonly, inherit);
1384 1076 : if (ret)
1385 11 : goto free_inherit;
1386 1065 : free_inherit:
1387 1076 : kfree(inherit);
1388 1076 : free_args:
1389 1076 : kfree(vol_args);
1390 1076 : return ret;
1391 : }
1392 :
1393 601 : static noinline int btrfs_ioctl_subvol_getflags(struct inode *inode,
1394 : void __user *arg)
1395 : {
1396 601 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1397 601 : struct btrfs_root *root = BTRFS_I(inode)->root;
1398 601 : int ret = 0;
1399 601 : u64 flags = 0;
1400 :
1401 601 : if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID)
1402 : return -EINVAL;
1403 :
1404 601 : down_read(&fs_info->subvol_sem);
1405 602 : if (btrfs_root_readonly(root))
1406 367 : flags |= BTRFS_SUBVOL_RDONLY;
1407 602 : up_read(&fs_info->subvol_sem);
1408 :
1409 602 : if (copy_to_user(arg, &flags, sizeof(flags)))
1410 0 : ret = -EFAULT;
1411 :
1412 : return ret;
1413 : }
1414 :
1415 224 : static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
1416 : void __user *arg)
1417 : {
1418 224 : struct inode *inode = file_inode(file);
1419 224 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1420 224 : struct btrfs_root *root = BTRFS_I(inode)->root;
1421 224 : struct btrfs_trans_handle *trans;
1422 224 : u64 root_flags;
1423 224 : u64 flags;
1424 224 : int ret = 0;
1425 :
1426 224 : if (!inode_owner_or_capable(file_mnt_idmap(file), inode))
1427 : return -EPERM;
1428 :
1429 220 : ret = mnt_want_write_file(file);
1430 220 : if (ret)
1431 0 : goto out;
1432 :
1433 220 : if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
1434 0 : ret = -EINVAL;
1435 0 : goto out_drop_write;
1436 : }
1437 :
1438 220 : if (copy_from_user(&flags, arg, sizeof(flags))) {
1439 0 : ret = -EFAULT;
1440 0 : goto out_drop_write;
1441 : }
1442 :
1443 220 : if (flags & ~BTRFS_SUBVOL_RDONLY) {
1444 0 : ret = -EOPNOTSUPP;
1445 0 : goto out_drop_write;
1446 : }
1447 :
1448 220 : down_write(&fs_info->subvol_sem);
1449 :
1450 : /* nothing to do */
1451 220 : if (!!(flags & BTRFS_SUBVOL_RDONLY) == btrfs_root_readonly(root))
1452 0 : goto out_drop_sem;
1453 :
1454 220 : root_flags = btrfs_root_flags(&root->root_item);
1455 220 : if (flags & BTRFS_SUBVOL_RDONLY) {
1456 207 : btrfs_set_root_flags(&root->root_item,
1457 : root_flags | BTRFS_ROOT_SUBVOL_RDONLY);
1458 : } else {
1459 : /*
1460 : * Block RO -> RW transition if this subvolume is involved in
1461 : * send
1462 : */
1463 13 : spin_lock(&root->root_item_lock);
1464 13 : if (root->send_in_progress == 0) {
1465 13 : btrfs_set_root_flags(&root->root_item,
1466 : root_flags & ~BTRFS_ROOT_SUBVOL_RDONLY);
1467 13 : spin_unlock(&root->root_item_lock);
1468 : } else {
1469 0 : spin_unlock(&root->root_item_lock);
1470 0 : btrfs_warn(fs_info,
1471 : "Attempt to set subvolume %llu read-write during send",
1472 : root->root_key.objectid);
1473 0 : ret = -EPERM;
1474 0 : goto out_drop_sem;
1475 : }
1476 : }
1477 :
1478 220 : trans = btrfs_start_transaction(root, 1);
1479 220 : if (IS_ERR(trans)) {
1480 0 : ret = PTR_ERR(trans);
1481 0 : goto out_reset;
1482 : }
1483 :
1484 220 : ret = btrfs_update_root(trans, fs_info->tree_root,
1485 : &root->root_key, &root->root_item);
1486 220 : if (ret < 0) {
1487 0 : btrfs_end_transaction(trans);
1488 0 : goto out_reset;
1489 : }
1490 :
1491 220 : ret = btrfs_commit_transaction(trans);
1492 :
1493 220 : out_reset:
1494 220 : if (ret)
1495 0 : btrfs_set_root_flags(&root->root_item, root_flags);
1496 220 : out_drop_sem:
1497 220 : up_write(&fs_info->subvol_sem);
1498 220 : out_drop_write:
1499 220 : mnt_drop_write_file(file);
1500 : out:
1501 : return ret;
1502 : }
1503 :
1504 42620 : static noinline int key_in_sk(struct btrfs_key *key,
1505 : struct btrfs_ioctl_search_key *sk)
1506 : {
1507 42620 : struct btrfs_key test;
1508 42620 : int ret;
1509 :
1510 42620 : test.objectid = sk->min_objectid;
1511 42620 : test.type = sk->min_type;
1512 42620 : test.offset = sk->min_offset;
1513 :
1514 42620 : ret = btrfs_comp_cpu_keys(key, &test);
1515 42620 : if (ret < 0)
1516 : return 0;
1517 :
1518 42620 : test.objectid = sk->max_objectid;
1519 42620 : test.type = sk->max_type;
1520 42620 : test.offset = sk->max_offset;
1521 :
1522 42620 : ret = btrfs_comp_cpu_keys(key, &test);
1523 42620 : if (ret > 0)
1524 35120 : return 0;
1525 : return 1;
1526 : }
1527 :
1528 9219 : static noinline int copy_to_sk(struct btrfs_path *path,
1529 : struct btrfs_key *key,
1530 : struct btrfs_ioctl_search_key *sk,
1531 : size_t *buf_size,
1532 : char __user *ubuf,
1533 : unsigned long *sk_offset,
1534 : int *num_found)
1535 : {
1536 9219 : u64 found_transid;
1537 9219 : struct extent_buffer *leaf;
1538 9219 : struct btrfs_ioctl_search_header sh;
1539 9219 : struct btrfs_key test;
1540 9219 : unsigned long item_off;
1541 9219 : unsigned long item_len;
1542 9219 : int nritems;
1543 9219 : int i;
1544 9219 : int slot;
1545 9219 : int ret = 0;
1546 :
1547 9219 : leaf = path->nodes[0];
1548 9219 : slot = path->slots[0];
1549 9219 : nritems = btrfs_header_nritems(leaf);
1550 :
1551 9219 : if (btrfs_header_generation(leaf) > sk->max_transid) {
1552 0 : i = nritems;
1553 0 : goto advance_key;
1554 : }
1555 : found_transid = btrfs_header_generation(leaf);
1556 :
1557 46791 : for (i = slot; i < nritems; i++) {
1558 42620 : item_off = btrfs_item_ptr_offset(leaf, i);
1559 42620 : item_len = btrfs_item_size(leaf, i);
1560 :
1561 42620 : btrfs_item_key_to_cpu(leaf, key, i);
1562 42620 : if (!key_in_sk(key, sk))
1563 35120 : continue;
1564 :
1565 7500 : if (sizeof(sh) + item_len > *buf_size) {
1566 0 : if (*num_found) {
1567 0 : ret = 1;
1568 0 : goto out;
1569 : }
1570 :
1571 : /*
1572 : * return one empty item back for v1, which does not
1573 : * handle -EOVERFLOW
1574 : */
1575 :
1576 0 : *buf_size = sizeof(sh) + item_len;
1577 0 : item_len = 0;
1578 0 : ret = -EOVERFLOW;
1579 : }
1580 :
1581 7500 : if (sizeof(sh) + item_len + *sk_offset > *buf_size) {
1582 1 : ret = 1;
1583 1 : goto out;
1584 : }
1585 :
1586 7499 : sh.objectid = key->objectid;
1587 7499 : sh.offset = key->offset;
1588 7499 : sh.type = key->type;
1589 7499 : sh.len = item_len;
1590 7499 : sh.transid = found_transid;
1591 :
1592 : /*
1593 : * Copy search result header. If we fault then loop again so we
1594 : * can fault in the pages and -EFAULT there if there's a
1595 : * problem. Otherwise we'll fault and then copy the buffer in
1596 : * properly this next time through
1597 : */
1598 7499 : if (copy_to_user_nofault(ubuf + *sk_offset, &sh, sizeof(sh))) {
1599 0 : ret = 0;
1600 0 : goto out;
1601 : }
1602 :
1603 7499 : *sk_offset += sizeof(sh);
1604 :
1605 7499 : if (item_len) {
1606 7485 : char __user *up = ubuf + *sk_offset;
1607 : /*
1608 : * Copy the item, same behavior as above, but reset the
1609 : * * sk_offset so we copy the full thing again.
1610 : */
1611 7485 : if (read_extent_buffer_to_user_nofault(leaf, up,
1612 : item_off, item_len)) {
1613 0 : ret = 0;
1614 0 : *sk_offset -= sizeof(sh);
1615 0 : goto out;
1616 : }
1617 :
1618 7485 : *sk_offset += item_len;
1619 : }
1620 7499 : (*num_found)++;
1621 :
1622 7499 : if (ret) /* -EOVERFLOW from above */
1623 0 : goto out;
1624 :
1625 7499 : if (*num_found >= sk->nr_items) {
1626 5047 : ret = 1;
1627 5047 : goto out;
1628 : }
1629 : }
1630 4171 : advance_key:
1631 4171 : ret = 0;
1632 4171 : test.objectid = sk->max_objectid;
1633 4171 : test.type = sk->max_type;
1634 4171 : test.offset = sk->max_offset;
1635 4171 : if (btrfs_comp_cpu_keys(key, &test) >= 0)
1636 : ret = 1;
1637 11 : else if (key->offset < (u64)-1)
1638 11 : key->offset++;
1639 0 : else if (key->type < (u8)-1) {
1640 0 : key->offset = 0;
1641 0 : key->type++;
1642 0 : } else if (key->objectid < (u64)-1) {
1643 0 : key->offset = 0;
1644 0 : key->type = 0;
1645 0 : key->objectid++;
1646 : } else
1647 : ret = 1;
1648 9219 : out:
1649 : /*
1650 : * 0: all items from this leaf copied, continue with next
1651 : * 1: * more items can be copied, but unused buffer is too small
1652 : * * all items were found
1653 : * Either way, it will stops the loop which iterates to the next
1654 : * leaf
1655 : * -EOVERFLOW: item was to large for buffer
1656 : * -EFAULT: could not copy extent buffer back to userspace
1657 : */
1658 9219 : return ret;
1659 : }
1660 :
1661 9229 : static noinline int search_ioctl(struct inode *inode,
1662 : struct btrfs_ioctl_search_key *sk,
1663 : size_t *buf_size,
1664 : char __user *ubuf)
1665 : {
1666 9229 : struct btrfs_fs_info *info = btrfs_sb(inode->i_sb);
1667 9229 : struct btrfs_root *root;
1668 9229 : struct btrfs_key key;
1669 9229 : struct btrfs_path *path;
1670 9229 : int ret;
1671 9229 : int num_found = 0;
1672 9229 : unsigned long sk_offset = 0;
1673 :
1674 9229 : if (*buf_size < sizeof(struct btrfs_ioctl_search_header)) {
1675 0 : *buf_size = sizeof(struct btrfs_ioctl_search_header);
1676 0 : return -EOVERFLOW;
1677 : }
1678 :
1679 9229 : path = btrfs_alloc_path();
1680 9229 : if (!path)
1681 : return -ENOMEM;
1682 :
1683 9229 : if (sk->tree_id == 0) {
1684 : /* search the root of the inode that was passed */
1685 0 : root = btrfs_grab_root(BTRFS_I(inode)->root);
1686 : } else {
1687 9229 : root = btrfs_get_fs_root(info, sk->tree_id, true);
1688 9229 : if (IS_ERR(root)) {
1689 0 : btrfs_free_path(path);
1690 0 : return PTR_ERR(root);
1691 : }
1692 : }
1693 :
1694 9229 : key.objectid = sk->min_objectid;
1695 9229 : key.type = sk->min_type;
1696 9229 : key.offset = sk->min_offset;
1697 :
1698 9240 : while (1) {
1699 9240 : ret = -EFAULT;
1700 : /*
1701 : * Ensure that the whole user buffer is faulted in at sub-page
1702 : * granularity, otherwise the loop may live-lock.
1703 : */
1704 9240 : if (fault_in_subpage_writeable(ubuf + sk_offset,
1705 9240 : *buf_size - sk_offset))
1706 : break;
1707 :
1708 9240 : ret = btrfs_search_forward(root, &key, path, sk->min_transid);
1709 9240 : if (ret != 0) {
1710 21 : if (ret > 0)
1711 : ret = 0;
1712 21 : goto err;
1713 : }
1714 9219 : ret = copy_to_sk(path, &key, sk, buf_size, ubuf,
1715 : &sk_offset, &num_found);
1716 9219 : btrfs_release_path(path);
1717 9219 : if (ret)
1718 : break;
1719 :
1720 : }
1721 9208 : if (ret > 0)
1722 : ret = 0;
1723 9208 : err:
1724 9229 : sk->nr_items = num_found;
1725 9229 : btrfs_put_root(root);
1726 9229 : btrfs_free_path(path);
1727 9229 : return ret;
1728 : }
1729 :
1730 9229 : static noinline int btrfs_ioctl_tree_search(struct inode *inode,
1731 : void __user *argp)
1732 : {
1733 9229 : struct btrfs_ioctl_search_args __user *uargs = argp;
1734 9229 : struct btrfs_ioctl_search_key sk;
1735 9229 : int ret;
1736 9229 : size_t buf_size;
1737 :
1738 9229 : if (!capable(CAP_SYS_ADMIN))
1739 : return -EPERM;
1740 :
1741 9229 : if (copy_from_user(&sk, &uargs->key, sizeof(sk)))
1742 : return -EFAULT;
1743 :
1744 9229 : buf_size = sizeof(uargs->buf);
1745 :
1746 9229 : ret = search_ioctl(inode, &sk, &buf_size, uargs->buf);
1747 :
1748 : /*
1749 : * In the origin implementation an overflow is handled by returning a
1750 : * search header with a len of zero, so reset ret.
1751 : */
1752 9229 : if (ret == -EOVERFLOW)
1753 : ret = 0;
1754 :
1755 18458 : if (ret == 0 && copy_to_user(&uargs->key, &sk, sizeof(sk)))
1756 0 : ret = -EFAULT;
1757 : return ret;
1758 : }
1759 :
1760 0 : static noinline int btrfs_ioctl_tree_search_v2(struct inode *inode,
1761 : void __user *argp)
1762 : {
1763 0 : struct btrfs_ioctl_search_args_v2 __user *uarg = argp;
1764 0 : struct btrfs_ioctl_search_args_v2 args;
1765 0 : int ret;
1766 0 : size_t buf_size;
1767 0 : const size_t buf_limit = SZ_16M;
1768 :
1769 0 : if (!capable(CAP_SYS_ADMIN))
1770 : return -EPERM;
1771 :
1772 : /* copy search header and buffer size */
1773 0 : if (copy_from_user(&args, uarg, sizeof(args)))
1774 : return -EFAULT;
1775 :
1776 0 : buf_size = args.buf_size;
1777 :
1778 : /* limit result size to 16MB */
1779 0 : if (buf_size > buf_limit)
1780 0 : buf_size = buf_limit;
1781 :
1782 0 : ret = search_ioctl(inode, &args.key, &buf_size,
1783 0 : (char __user *)(&uarg->buf[0]));
1784 0 : if (ret == 0 && copy_to_user(&uarg->key, &args.key, sizeof(args.key)))
1785 : ret = -EFAULT;
1786 0 : else if (ret == -EOVERFLOW &&
1787 0 : copy_to_user(&uarg->buf_size, &buf_size, sizeof(buf_size)))
1788 0 : ret = -EFAULT;
1789 :
1790 : return ret;
1791 : }
1792 :
1793 : /*
1794 : * Search INODE_REFs to identify path name of 'dirid' directory
1795 : * in a 'tree_id' tree. and sets path name to 'name'.
1796 : */
1797 1720 : static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
1798 : u64 tree_id, u64 dirid, char *name)
1799 : {
1800 1720 : struct btrfs_root *root;
1801 1720 : struct btrfs_key key;
1802 1720 : char *ptr;
1803 1720 : int ret = -1;
1804 1720 : int slot;
1805 1720 : int len;
1806 1720 : int total_len = 0;
1807 1720 : struct btrfs_inode_ref *iref;
1808 1720 : struct extent_buffer *l;
1809 1720 : struct btrfs_path *path;
1810 :
1811 1720 : if (dirid == BTRFS_FIRST_FREE_OBJECTID) {
1812 0 : name[0]='\0';
1813 0 : return 0;
1814 : }
1815 :
1816 1720 : path = btrfs_alloc_path();
1817 1720 : if (!path)
1818 : return -ENOMEM;
1819 :
1820 1720 : ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1];
1821 :
1822 1720 : root = btrfs_get_fs_root(info, tree_id, true);
1823 1720 : if (IS_ERR(root)) {
1824 0 : ret = PTR_ERR(root);
1825 0 : root = NULL;
1826 0 : goto out;
1827 : }
1828 :
1829 1720 : key.objectid = dirid;
1830 1720 : key.type = BTRFS_INODE_REF_KEY;
1831 1720 : key.offset = (u64)-1;
1832 :
1833 1720 : while (1) {
1834 1720 : ret = btrfs_search_backwards(root, &key, path);
1835 1720 : if (ret < 0)
1836 0 : goto out;
1837 1720 : else if (ret > 0) {
1838 0 : ret = -ENOENT;
1839 0 : goto out;
1840 : }
1841 :
1842 1720 : l = path->nodes[0];
1843 1720 : slot = path->slots[0];
1844 :
1845 1720 : iref = btrfs_item_ptr(l, slot, struct btrfs_inode_ref);
1846 1720 : len = btrfs_inode_ref_name_len(l, iref);
1847 1720 : ptr -= len + 1;
1848 1720 : total_len += len + 1;
1849 1720 : if (ptr < name) {
1850 0 : ret = -ENAMETOOLONG;
1851 0 : goto out;
1852 : }
1853 :
1854 1720 : *(ptr + len) = '/';
1855 1720 : read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len);
1856 :
1857 1720 : if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
1858 : break;
1859 :
1860 0 : btrfs_release_path(path);
1861 0 : key.objectid = key.offset;
1862 0 : key.offset = (u64)-1;
1863 0 : dirid = key.objectid;
1864 : }
1865 3440 : memmove(name, ptr, total_len);
1866 1720 : name[total_len] = '\0';
1867 1720 : ret = 0;
1868 1720 : out:
1869 1720 : btrfs_put_root(root);
1870 1720 : btrfs_free_path(path);
1871 1720 : return ret;
1872 : }
1873 :
1874 8 : static int btrfs_search_path_in_tree_user(struct mnt_idmap *idmap,
1875 : struct inode *inode,
1876 : struct btrfs_ioctl_ino_lookup_user_args *args)
1877 : {
1878 8 : struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
1879 8 : struct super_block *sb = inode->i_sb;
1880 8 : struct btrfs_key upper_limit = BTRFS_I(inode)->location;
1881 8 : u64 treeid = BTRFS_I(inode)->root->root_key.objectid;
1882 8 : u64 dirid = args->dirid;
1883 8 : unsigned long item_off;
1884 8 : unsigned long item_len;
1885 8 : struct btrfs_inode_ref *iref;
1886 8 : struct btrfs_root_ref *rref;
1887 8 : struct btrfs_root *root = NULL;
1888 8 : struct btrfs_path *path;
1889 8 : struct btrfs_key key, key2;
1890 8 : struct extent_buffer *leaf;
1891 8 : struct inode *temp_inode;
1892 8 : char *ptr;
1893 8 : int slot;
1894 8 : int len;
1895 8 : int total_len = 0;
1896 8 : int ret;
1897 :
1898 8 : path = btrfs_alloc_path();
1899 8 : if (!path)
1900 : return -ENOMEM;
1901 :
1902 : /*
1903 : * If the bottom subvolume does not exist directly under upper_limit,
1904 : * construct the path in from the bottom up.
1905 : */
1906 8 : if (dirid != upper_limit.objectid) {
1907 4 : ptr = &args->path[BTRFS_INO_LOOKUP_USER_PATH_MAX - 1];
1908 :
1909 4 : root = btrfs_get_fs_root(fs_info, treeid, true);
1910 4 : if (IS_ERR(root)) {
1911 0 : ret = PTR_ERR(root);
1912 0 : goto out;
1913 : }
1914 :
1915 4 : key.objectid = dirid;
1916 4 : key.type = BTRFS_INODE_REF_KEY;
1917 4 : key.offset = (u64)-1;
1918 12 : while (1) {
1919 8 : ret = btrfs_search_backwards(root, &key, path);
1920 8 : if (ret < 0)
1921 0 : goto out_put;
1922 8 : else if (ret > 0) {
1923 0 : ret = -ENOENT;
1924 0 : goto out_put;
1925 : }
1926 :
1927 8 : leaf = path->nodes[0];
1928 8 : slot = path->slots[0];
1929 :
1930 8 : iref = btrfs_item_ptr(leaf, slot, struct btrfs_inode_ref);
1931 8 : len = btrfs_inode_ref_name_len(leaf, iref);
1932 8 : ptr -= len + 1;
1933 8 : total_len += len + 1;
1934 8 : if (ptr < args->path) {
1935 0 : ret = -ENAMETOOLONG;
1936 0 : goto out_put;
1937 : }
1938 :
1939 8 : *(ptr + len) = '/';
1940 8 : read_extent_buffer(leaf, ptr,
1941 8 : (unsigned long)(iref + 1), len);
1942 :
1943 : /* Check the read+exec permission of this directory */
1944 8 : ret = btrfs_previous_item(root, path, dirid,
1945 : BTRFS_INODE_ITEM_KEY);
1946 8 : if (ret < 0) {
1947 0 : goto out_put;
1948 8 : } else if (ret > 0) {
1949 0 : ret = -ENOENT;
1950 0 : goto out_put;
1951 : }
1952 :
1953 8 : leaf = path->nodes[0];
1954 8 : slot = path->slots[0];
1955 8 : btrfs_item_key_to_cpu(leaf, &key2, slot);
1956 8 : if (key2.objectid != dirid) {
1957 0 : ret = -ENOENT;
1958 0 : goto out_put;
1959 : }
1960 :
1961 8 : temp_inode = btrfs_iget(sb, key2.objectid, root);
1962 8 : if (IS_ERR(temp_inode)) {
1963 0 : ret = PTR_ERR(temp_inode);
1964 0 : goto out_put;
1965 : }
1966 8 : ret = inode_permission(idmap, temp_inode,
1967 : MAY_READ | MAY_EXEC);
1968 8 : iput(temp_inode);
1969 8 : if (ret) {
1970 0 : ret = -EACCES;
1971 0 : goto out_put;
1972 : }
1973 :
1974 8 : if (key.offset == upper_limit.objectid)
1975 : break;
1976 4 : if (key.objectid == BTRFS_FIRST_FREE_OBJECTID) {
1977 0 : ret = -EACCES;
1978 0 : goto out_put;
1979 : }
1980 :
1981 4 : btrfs_release_path(path);
1982 4 : key.objectid = key.offset;
1983 4 : key.offset = (u64)-1;
1984 4 : dirid = key.objectid;
1985 : }
1986 :
1987 8 : memmove(args->path, ptr, total_len);
1988 4 : args->path[total_len] = '\0';
1989 4 : btrfs_put_root(root);
1990 4 : root = NULL;
1991 4 : btrfs_release_path(path);
1992 : }
1993 :
1994 : /* Get the bottom subvolume's name from ROOT_REF */
1995 8 : key.objectid = treeid;
1996 8 : key.type = BTRFS_ROOT_REF_KEY;
1997 8 : key.offset = args->treeid;
1998 8 : ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1999 8 : if (ret < 0) {
2000 0 : goto out;
2001 8 : } else if (ret > 0) {
2002 0 : ret = -ENOENT;
2003 0 : goto out;
2004 : }
2005 :
2006 8 : leaf = path->nodes[0];
2007 8 : slot = path->slots[0];
2008 8 : btrfs_item_key_to_cpu(leaf, &key, slot);
2009 :
2010 8 : item_off = btrfs_item_ptr_offset(leaf, slot);
2011 8 : item_len = btrfs_item_size(leaf, slot);
2012 : /* Check if dirid in ROOT_REF corresponds to passed dirid */
2013 8 : rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
2014 8 : if (args->dirid != btrfs_root_ref_dirid(leaf, rref)) {
2015 0 : ret = -EINVAL;
2016 0 : goto out;
2017 : }
2018 :
2019 : /* Copy subvolume's name */
2020 8 : item_off += sizeof(struct btrfs_root_ref);
2021 8 : item_len -= sizeof(struct btrfs_root_ref);
2022 8 : read_extent_buffer(leaf, args->name, item_off, item_len);
2023 8 : args->name[item_len] = 0;
2024 :
2025 8 : out_put:
2026 8 : btrfs_put_root(root);
2027 8 : out:
2028 8 : btrfs_free_path(path);
2029 8 : return ret;
2030 : }
2031 :
2032 4921 : static noinline int btrfs_ioctl_ino_lookup(struct btrfs_root *root,
2033 : void __user *argp)
2034 : {
2035 4921 : struct btrfs_ioctl_ino_lookup_args *args;
2036 4921 : int ret = 0;
2037 :
2038 4921 : args = memdup_user(argp, sizeof(*args));
2039 4921 : if (IS_ERR(args))
2040 0 : return PTR_ERR(args);
2041 :
2042 : /*
2043 : * Unprivileged query to obtain the containing subvolume root id. The
2044 : * path is reset so it's consistent with btrfs_search_path_in_tree.
2045 : */
2046 4921 : if (args->treeid == 0)
2047 3171 : args->treeid = root->root_key.objectid;
2048 :
2049 4921 : if (args->objectid == BTRFS_FIRST_FREE_OBJECTID) {
2050 3201 : args->name[0] = 0;
2051 3201 : goto out;
2052 : }
2053 :
2054 1720 : if (!capable(CAP_SYS_ADMIN)) {
2055 0 : ret = -EPERM;
2056 0 : goto out;
2057 : }
2058 :
2059 1720 : ret = btrfs_search_path_in_tree(root->fs_info,
2060 : args->treeid, args->objectid,
2061 1720 : args->name);
2062 :
2063 : out:
2064 9842 : if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2065 : ret = -EFAULT;
2066 :
2067 4921 : kfree(args);
2068 4921 : return ret;
2069 : }
2070 :
2071 : /*
2072 : * Version of ino_lookup ioctl (unprivileged)
2073 : *
2074 : * The main differences from ino_lookup ioctl are:
2075 : *
2076 : * 1. Read + Exec permission will be checked using inode_permission() during
2077 : * path construction. -EACCES will be returned in case of failure.
2078 : * 2. Path construction will be stopped at the inode number which corresponds
2079 : * to the fd with which this ioctl is called. If constructed path does not
2080 : * exist under fd's inode, -EACCES will be returned.
2081 : * 3. The name of bottom subvolume is also searched and filled.
2082 : */
2083 8 : static int btrfs_ioctl_ino_lookup_user(struct file *file, void __user *argp)
2084 : {
2085 8 : struct btrfs_ioctl_ino_lookup_user_args *args;
2086 8 : struct inode *inode;
2087 8 : int ret;
2088 :
2089 8 : args = memdup_user(argp, sizeof(*args));
2090 8 : if (IS_ERR(args))
2091 0 : return PTR_ERR(args);
2092 :
2093 8 : inode = file_inode(file);
2094 :
2095 8 : if (args->dirid == BTRFS_FIRST_FREE_OBJECTID &&
2096 4 : BTRFS_I(inode)->location.objectid != BTRFS_FIRST_FREE_OBJECTID) {
2097 : /*
2098 : * The subvolume does not exist under fd with which this is
2099 : * called
2100 : */
2101 0 : kfree(args);
2102 0 : return -EACCES;
2103 : }
2104 :
2105 8 : ret = btrfs_search_path_in_tree_user(file_mnt_idmap(file), inode, args);
2106 :
2107 16 : if (ret == 0 && copy_to_user(argp, args, sizeof(*args)))
2108 : ret = -EFAULT;
2109 :
2110 8 : kfree(args);
2111 8 : return ret;
2112 : }
2113 :
2114 : /* Get the subvolume information in BTRFS_ROOT_ITEM and BTRFS_ROOT_BACKREF */
2115 0 : static int btrfs_ioctl_get_subvol_info(struct inode *inode, void __user *argp)
2116 : {
2117 0 : struct btrfs_ioctl_get_subvol_info_args *subvol_info;
2118 0 : struct btrfs_fs_info *fs_info;
2119 0 : struct btrfs_root *root;
2120 0 : struct btrfs_path *path;
2121 0 : struct btrfs_key key;
2122 0 : struct btrfs_root_item *root_item;
2123 0 : struct btrfs_root_ref *rref;
2124 0 : struct extent_buffer *leaf;
2125 0 : unsigned long item_off;
2126 0 : unsigned long item_len;
2127 0 : int slot;
2128 0 : int ret = 0;
2129 :
2130 0 : path = btrfs_alloc_path();
2131 0 : if (!path)
2132 : return -ENOMEM;
2133 :
2134 0 : subvol_info = kzalloc(sizeof(*subvol_info), GFP_KERNEL);
2135 0 : if (!subvol_info) {
2136 0 : btrfs_free_path(path);
2137 0 : return -ENOMEM;
2138 : }
2139 :
2140 0 : fs_info = BTRFS_I(inode)->root->fs_info;
2141 :
2142 : /* Get root_item of inode's subvolume */
2143 0 : key.objectid = BTRFS_I(inode)->root->root_key.objectid;
2144 0 : root = btrfs_get_fs_root(fs_info, key.objectid, true);
2145 0 : if (IS_ERR(root)) {
2146 0 : ret = PTR_ERR(root);
2147 0 : goto out_free;
2148 : }
2149 0 : root_item = &root->root_item;
2150 :
2151 0 : subvol_info->treeid = key.objectid;
2152 :
2153 0 : subvol_info->generation = btrfs_root_generation(root_item);
2154 0 : subvol_info->flags = btrfs_root_flags(root_item);
2155 :
2156 0 : memcpy(subvol_info->uuid, root_item->uuid, BTRFS_UUID_SIZE);
2157 0 : memcpy(subvol_info->parent_uuid, root_item->parent_uuid,
2158 : BTRFS_UUID_SIZE);
2159 0 : memcpy(subvol_info->received_uuid, root_item->received_uuid,
2160 : BTRFS_UUID_SIZE);
2161 :
2162 0 : subvol_info->ctransid = btrfs_root_ctransid(root_item);
2163 0 : subvol_info->ctime.sec = btrfs_stack_timespec_sec(&root_item->ctime);
2164 0 : subvol_info->ctime.nsec = btrfs_stack_timespec_nsec(&root_item->ctime);
2165 :
2166 0 : subvol_info->otransid = btrfs_root_otransid(root_item);
2167 0 : subvol_info->otime.sec = btrfs_stack_timespec_sec(&root_item->otime);
2168 0 : subvol_info->otime.nsec = btrfs_stack_timespec_nsec(&root_item->otime);
2169 :
2170 0 : subvol_info->stransid = btrfs_root_stransid(root_item);
2171 0 : subvol_info->stime.sec = btrfs_stack_timespec_sec(&root_item->stime);
2172 0 : subvol_info->stime.nsec = btrfs_stack_timespec_nsec(&root_item->stime);
2173 :
2174 0 : subvol_info->rtransid = btrfs_root_rtransid(root_item);
2175 0 : subvol_info->rtime.sec = btrfs_stack_timespec_sec(&root_item->rtime);
2176 0 : subvol_info->rtime.nsec = btrfs_stack_timespec_nsec(&root_item->rtime);
2177 :
2178 0 : if (key.objectid != BTRFS_FS_TREE_OBJECTID) {
2179 : /* Search root tree for ROOT_BACKREF of this subvolume */
2180 0 : key.type = BTRFS_ROOT_BACKREF_KEY;
2181 0 : key.offset = 0;
2182 0 : ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
2183 0 : if (ret < 0) {
2184 0 : goto out;
2185 0 : } else if (path->slots[0] >=
2186 0 : btrfs_header_nritems(path->nodes[0])) {
2187 0 : ret = btrfs_next_leaf(fs_info->tree_root, path);
2188 0 : if (ret < 0) {
2189 0 : goto out;
2190 0 : } else if (ret > 0) {
2191 0 : ret = -EUCLEAN;
2192 0 : goto out;
2193 : }
2194 : }
2195 :
2196 0 : leaf = path->nodes[0];
2197 0 : slot = path->slots[0];
2198 0 : btrfs_item_key_to_cpu(leaf, &key, slot);
2199 0 : if (key.objectid == subvol_info->treeid &&
2200 0 : key.type == BTRFS_ROOT_BACKREF_KEY) {
2201 0 : subvol_info->parent_id = key.offset;
2202 :
2203 0 : rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
2204 0 : subvol_info->dirid = btrfs_root_ref_dirid(leaf, rref);
2205 :
2206 0 : item_off = btrfs_item_ptr_offset(leaf, slot)
2207 : + sizeof(struct btrfs_root_ref);
2208 0 : item_len = btrfs_item_size(leaf, slot)
2209 : - sizeof(struct btrfs_root_ref);
2210 0 : read_extent_buffer(leaf, subvol_info->name,
2211 : item_off, item_len);
2212 : } else {
2213 0 : ret = -ENOENT;
2214 0 : goto out;
2215 : }
2216 : }
2217 :
2218 0 : btrfs_free_path(path);
2219 0 : path = NULL;
2220 0 : if (copy_to_user(argp, subvol_info, sizeof(*subvol_info)))
2221 : ret = -EFAULT;
2222 :
2223 0 : out:
2224 0 : btrfs_put_root(root);
2225 0 : out_free:
2226 0 : btrfs_free_path(path);
2227 0 : kfree(subvol_info);
2228 0 : return ret;
2229 : }
2230 :
2231 : /*
2232 : * Return ROOT_REF information of the subvolume containing this inode
2233 : * except the subvolume name.
2234 : */
2235 12 : static int btrfs_ioctl_get_subvol_rootref(struct btrfs_root *root,
2236 : void __user *argp)
2237 : {
2238 12 : struct btrfs_ioctl_get_subvol_rootref_args *rootrefs;
2239 12 : struct btrfs_root_ref *rref;
2240 12 : struct btrfs_path *path;
2241 12 : struct btrfs_key key;
2242 12 : struct extent_buffer *leaf;
2243 12 : u64 objectid;
2244 12 : int slot;
2245 12 : int ret;
2246 12 : u8 found;
2247 :
2248 12 : path = btrfs_alloc_path();
2249 12 : if (!path)
2250 : return -ENOMEM;
2251 :
2252 12 : rootrefs = memdup_user(argp, sizeof(*rootrefs));
2253 12 : if (IS_ERR(rootrefs)) {
2254 0 : btrfs_free_path(path);
2255 0 : return PTR_ERR(rootrefs);
2256 : }
2257 :
2258 12 : objectid = root->root_key.objectid;
2259 12 : key.objectid = objectid;
2260 12 : key.type = BTRFS_ROOT_REF_KEY;
2261 12 : key.offset = rootrefs->min_treeid;
2262 12 : found = 0;
2263 :
2264 12 : root = root->fs_info->tree_root;
2265 12 : ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2266 12 : if (ret < 0) {
2267 0 : goto out;
2268 12 : } else if (path->slots[0] >=
2269 12 : btrfs_header_nritems(path->nodes[0])) {
2270 0 : ret = btrfs_next_leaf(root, path);
2271 0 : if (ret < 0) {
2272 0 : goto out;
2273 0 : } else if (ret > 0) {
2274 0 : ret = -EUCLEAN;
2275 0 : goto out;
2276 : }
2277 : }
2278 20 : while (1) {
2279 20 : leaf = path->nodes[0];
2280 20 : slot = path->slots[0];
2281 :
2282 20 : btrfs_item_key_to_cpu(leaf, &key, slot);
2283 20 : if (key.objectid != objectid || key.type != BTRFS_ROOT_REF_KEY) {
2284 12 : ret = 0;
2285 12 : goto out;
2286 : }
2287 :
2288 8 : if (found == BTRFS_MAX_ROOTREF_BUFFER_NUM) {
2289 0 : ret = -EOVERFLOW;
2290 0 : goto out;
2291 : }
2292 :
2293 8 : rref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
2294 8 : rootrefs->rootref[found].treeid = key.offset;
2295 8 : rootrefs->rootref[found].dirid =
2296 : btrfs_root_ref_dirid(leaf, rref);
2297 8 : found++;
2298 :
2299 8 : ret = btrfs_next_item(root, path);
2300 8 : if (ret < 0) {
2301 0 : goto out;
2302 8 : } else if (ret > 0) {
2303 0 : ret = -EUCLEAN;
2304 0 : goto out;
2305 : }
2306 : }
2307 :
2308 12 : out:
2309 12 : btrfs_free_path(path);
2310 :
2311 12 : if (!ret || ret == -EOVERFLOW) {
2312 12 : rootrefs->num_items = found;
2313 : /* update min_treeid for next search */
2314 12 : if (found)
2315 4 : rootrefs->min_treeid =
2316 4 : rootrefs->rootref[found - 1].treeid + 1;
2317 24 : if (copy_to_user(argp, rootrefs, sizeof(*rootrefs)))
2318 : ret = -EFAULT;
2319 : }
2320 :
2321 12 : kfree(rootrefs);
2322 :
2323 12 : return ret;
2324 : }
2325 :
2326 166 : static noinline int btrfs_ioctl_snap_destroy(struct file *file,
2327 : void __user *arg,
2328 : bool destroy_v2)
2329 : {
2330 166 : struct dentry *parent = file->f_path.dentry;
2331 166 : struct btrfs_fs_info *fs_info = btrfs_sb(parent->d_sb);
2332 166 : struct dentry *dentry;
2333 166 : struct inode *dir = d_inode(parent);
2334 166 : struct inode *inode;
2335 166 : struct btrfs_root *root = BTRFS_I(dir)->root;
2336 166 : struct btrfs_root *dest = NULL;
2337 166 : struct btrfs_ioctl_vol_args *vol_args = NULL;
2338 166 : struct btrfs_ioctl_vol_args_v2 *vol_args2 = NULL;
2339 166 : struct mnt_idmap *idmap = file_mnt_idmap(file);
2340 166 : char *subvol_name, *subvol_name_ptr = NULL;
2341 166 : int subvol_namelen;
2342 166 : int err = 0;
2343 166 : bool destroy_parent = false;
2344 :
2345 : /* We don't support snapshots with extent tree v2 yet. */
2346 166 : if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
2347 0 : btrfs_err(fs_info,
2348 : "extent tree v2 doesn't support snapshot deletion yet");
2349 0 : return -EOPNOTSUPP;
2350 : }
2351 :
2352 166 : if (destroy_v2) {
2353 6 : vol_args2 = memdup_user(arg, sizeof(*vol_args2));
2354 6 : if (IS_ERR(vol_args2))
2355 0 : return PTR_ERR(vol_args2);
2356 :
2357 6 : if (vol_args2->flags & ~BTRFS_SUBVOL_DELETE_ARGS_MASK) {
2358 0 : err = -EOPNOTSUPP;
2359 0 : goto out;
2360 : }
2361 :
2362 : /*
2363 : * If SPEC_BY_ID is not set, we are looking for the subvolume by
2364 : * name, same as v1 currently does.
2365 : */
2366 6 : if (!(vol_args2->flags & BTRFS_SUBVOL_SPEC_BY_ID)) {
2367 0 : vol_args2->name[BTRFS_SUBVOL_NAME_MAX] = 0;
2368 0 : subvol_name = vol_args2->name;
2369 :
2370 0 : err = mnt_want_write_file(file);
2371 0 : if (err)
2372 0 : goto out;
2373 : } else {
2374 6 : struct inode *old_dir;
2375 :
2376 6 : if (vol_args2->subvolid < BTRFS_FIRST_FREE_OBJECTID) {
2377 0 : err = -EINVAL;
2378 0 : goto out;
2379 : }
2380 :
2381 6 : err = mnt_want_write_file(file);
2382 6 : if (err)
2383 0 : goto out;
2384 :
2385 6 : dentry = btrfs_get_dentry(fs_info->sb,
2386 : BTRFS_FIRST_FREE_OBJECTID,
2387 : vol_args2->subvolid, 0);
2388 6 : if (IS_ERR(dentry)) {
2389 0 : err = PTR_ERR(dentry);
2390 0 : goto out_drop_write;
2391 : }
2392 :
2393 : /*
2394 : * Change the default parent since the subvolume being
2395 : * deleted can be outside of the current mount point.
2396 : */
2397 6 : parent = btrfs_get_parent(dentry);
2398 :
2399 : /*
2400 : * At this point dentry->d_name can point to '/' if the
2401 : * subvolume we want to destroy is outsite of the
2402 : * current mount point, so we need to release the
2403 : * current dentry and execute the lookup to return a new
2404 : * one with ->d_name pointing to the
2405 : * <mount point>/subvol_name.
2406 : */
2407 6 : dput(dentry);
2408 6 : if (IS_ERR(parent)) {
2409 0 : err = PTR_ERR(parent);
2410 0 : goto out_drop_write;
2411 : }
2412 6 : old_dir = dir;
2413 6 : dir = d_inode(parent);
2414 :
2415 : /*
2416 : * If v2 was used with SPEC_BY_ID, a new parent was
2417 : * allocated since the subvolume can be outside of the
2418 : * current mount point. Later on we need to release this
2419 : * new parent dentry.
2420 : */
2421 6 : destroy_parent = true;
2422 :
2423 : /*
2424 : * On idmapped mounts, deletion via subvolid is
2425 : * restricted to subvolumes that are immediate
2426 : * ancestors of the inode referenced by the file
2427 : * descriptor in the ioctl. Otherwise the idmapping
2428 : * could potentially be abused to delete subvolumes
2429 : * anywhere in the filesystem the user wouldn't be able
2430 : * to delete without an idmapped mount.
2431 : */
2432 6 : if (old_dir != dir && idmap != &nop_mnt_idmap) {
2433 1 : err = -EOPNOTSUPP;
2434 1 : goto free_parent;
2435 : }
2436 :
2437 5 : subvol_name_ptr = btrfs_get_subvol_name_from_objectid(
2438 : fs_info, vol_args2->subvolid);
2439 5 : if (IS_ERR(subvol_name_ptr)) {
2440 0 : err = PTR_ERR(subvol_name_ptr);
2441 0 : goto free_parent;
2442 : }
2443 : /* subvol_name_ptr is already nul terminated */
2444 5 : subvol_name = (char *)kbasename(subvol_name_ptr);
2445 : }
2446 : } else {
2447 160 : vol_args = memdup_user(arg, sizeof(*vol_args));
2448 160 : if (IS_ERR(vol_args))
2449 0 : return PTR_ERR(vol_args);
2450 :
2451 160 : vol_args->name[BTRFS_PATH_NAME_MAX] = 0;
2452 160 : subvol_name = vol_args->name;
2453 :
2454 160 : err = mnt_want_write_file(file);
2455 160 : if (err)
2456 0 : goto out;
2457 : }
2458 :
2459 165 : subvol_namelen = strlen(subvol_name);
2460 :
2461 165 : if (strchr(subvol_name, '/') ||
2462 165 : strncmp(subvol_name, "..", subvol_namelen) == 0) {
2463 0 : err = -EINVAL;
2464 0 : goto free_subvol_name;
2465 : }
2466 :
2467 165 : if (!S_ISDIR(dir->i_mode)) {
2468 0 : err = -ENOTDIR;
2469 0 : goto free_subvol_name;
2470 : }
2471 :
2472 165 : err = down_write_killable_nested(&dir->i_rwsem, I_MUTEX_PARENT);
2473 165 : if (err == -EINTR)
2474 0 : goto free_subvol_name;
2475 165 : dentry = lookup_one(idmap, subvol_name, parent, subvol_namelen);
2476 165 : if (IS_ERR(dentry)) {
2477 0 : err = PTR_ERR(dentry);
2478 0 : goto out_unlock_dir;
2479 : }
2480 :
2481 165 : if (d_really_is_negative(dentry)) {
2482 0 : err = -ENOENT;
2483 0 : goto out_dput;
2484 : }
2485 :
2486 165 : inode = d_inode(dentry);
2487 165 : dest = BTRFS_I(inode)->root;
2488 165 : if (!capable(CAP_SYS_ADMIN)) {
2489 : /*
2490 : * Regular user. Only allow this with a special mount
2491 : * option, when the user has write+exec access to the
2492 : * subvol root, and when rmdir(2) would have been
2493 : * allowed.
2494 : *
2495 : * Note that this is _not_ check that the subvol is
2496 : * empty or doesn't contain data that we wouldn't
2497 : * otherwise be able to delete.
2498 : *
2499 : * Users who want to delete empty subvols should try
2500 : * rmdir(2).
2501 : */
2502 15 : err = -EPERM;
2503 15 : if (!btrfs_test_opt(fs_info, USER_SUBVOL_RM_ALLOWED))
2504 5 : goto out_dput;
2505 :
2506 : /*
2507 : * Do not allow deletion if the parent dir is the same
2508 : * as the dir to be deleted. That means the ioctl
2509 : * must be called on the dentry referencing the root
2510 : * of the subvol, not a random directory contained
2511 : * within it.
2512 : */
2513 10 : err = -EINVAL;
2514 10 : if (root == dest)
2515 0 : goto out_dput;
2516 :
2517 10 : err = inode_permission(idmap, inode, MAY_WRITE | MAY_EXEC);
2518 10 : if (err)
2519 2 : goto out_dput;
2520 : }
2521 :
2522 : /* check if subvolume may be deleted by a user */
2523 158 : err = btrfs_may_delete(idmap, dir, dentry, 1);
2524 158 : if (err)
2525 0 : goto out_dput;
2526 :
2527 158 : if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
2528 0 : err = -EINVAL;
2529 0 : goto out_dput;
2530 : }
2531 :
2532 158 : btrfs_inode_lock(BTRFS_I(inode), 0);
2533 158 : err = btrfs_delete_subvolume(BTRFS_I(dir), dentry);
2534 158 : btrfs_inode_unlock(BTRFS_I(inode), 0);
2535 158 : if (!err)
2536 157 : d_delete_notify(dir, dentry);
2537 :
2538 1 : out_dput:
2539 165 : dput(dentry);
2540 165 : out_unlock_dir:
2541 165 : btrfs_inode_unlock(BTRFS_I(dir), 0);
2542 165 : free_subvol_name:
2543 165 : kfree(subvol_name_ptr);
2544 166 : free_parent:
2545 166 : if (destroy_parent)
2546 6 : dput(parent);
2547 160 : out_drop_write:
2548 166 : mnt_drop_write_file(file);
2549 166 : out:
2550 166 : kfree(vol_args2);
2551 166 : kfree(vol_args);
2552 166 : return err;
2553 : }
2554 :
2555 189 : static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
2556 : {
2557 189 : struct inode *inode = file_inode(file);
2558 189 : struct btrfs_root *root = BTRFS_I(inode)->root;
2559 189 : struct btrfs_ioctl_defrag_range_args range = {0};
2560 189 : int ret;
2561 :
2562 189 : ret = mnt_want_write_file(file);
2563 189 : if (ret)
2564 : return ret;
2565 :
2566 189 : if (btrfs_root_readonly(root)) {
2567 0 : ret = -EROFS;
2568 0 : goto out;
2569 : }
2570 :
2571 189 : switch (inode->i_mode & S_IFMT) {
2572 2 : case S_IFDIR:
2573 2 : if (!capable(CAP_SYS_ADMIN)) {
2574 0 : ret = -EPERM;
2575 0 : goto out;
2576 : }
2577 2 : ret = btrfs_defrag_root(root);
2578 2 : break;
2579 187 : case S_IFREG:
2580 : /*
2581 : * Note that this does not check the file descriptor for write
2582 : * access. This prevents defragmenting executables that are
2583 : * running and allows defrag on files open in read-only mode.
2584 : */
2585 187 : if (!capable(CAP_SYS_ADMIN) &&
2586 0 : inode_permission(&nop_mnt_idmap, inode, MAY_WRITE)) {
2587 0 : ret = -EPERM;
2588 0 : goto out;
2589 : }
2590 :
2591 187 : if (argp) {
2592 187 : if (copy_from_user(&range, argp, sizeof(range))) {
2593 0 : ret = -EFAULT;
2594 0 : goto out;
2595 : }
2596 : /* compression requires us to start the IO */
2597 187 : if ((range.flags & BTRFS_DEFRAG_RANGE_COMPRESS)) {
2598 4 : range.flags |= BTRFS_DEFRAG_RANGE_START_IO;
2599 4 : range.extent_thresh = (u32)-1;
2600 : }
2601 : } else {
2602 : /* the rest are all set to zero by kzalloc */
2603 0 : range.len = (u64)-1;
2604 : }
2605 187 : ret = btrfs_defrag_file(file_inode(file), &file->f_ra,
2606 : &range, BTRFS_OLDEST_GENERATION, 0);
2607 187 : if (ret > 0)
2608 : ret = 0;
2609 : break;
2610 : default:
2611 : ret = -EINVAL;
2612 : }
2613 189 : out:
2614 189 : mnt_drop_write_file(file);
2615 189 : return ret;
2616 : }
2617 :
2618 0 : static long btrfs_ioctl_add_dev(struct btrfs_fs_info *fs_info, void __user *arg)
2619 : {
2620 0 : struct btrfs_ioctl_vol_args *vol_args;
2621 0 : bool restore_op = false;
2622 0 : int ret;
2623 :
2624 0 : if (!capable(CAP_SYS_ADMIN))
2625 : return -EPERM;
2626 :
2627 0 : if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
2628 0 : btrfs_err(fs_info, "device add not supported on extent tree v2 yet");
2629 0 : return -EINVAL;
2630 : }
2631 :
2632 0 : if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_ADD)) {
2633 0 : if (!btrfs_exclop_start_try_lock(fs_info, BTRFS_EXCLOP_DEV_ADD))
2634 : return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
2635 :
2636 : /*
2637 : * We can do the device add because we have a paused balanced,
2638 : * change the exclusive op type and remember we should bring
2639 : * back the paused balance
2640 : */
2641 0 : fs_info->exclusive_operation = BTRFS_EXCLOP_DEV_ADD;
2642 0 : btrfs_exclop_start_unlock(fs_info);
2643 0 : restore_op = true;
2644 : }
2645 :
2646 0 : vol_args = memdup_user(arg, sizeof(*vol_args));
2647 0 : if (IS_ERR(vol_args)) {
2648 0 : ret = PTR_ERR(vol_args);
2649 0 : goto out;
2650 : }
2651 :
2652 0 : vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2653 0 : ret = btrfs_init_new_device(fs_info, vol_args->name);
2654 :
2655 0 : if (!ret)
2656 0 : btrfs_info(fs_info, "disk added %s", vol_args->name);
2657 :
2658 0 : kfree(vol_args);
2659 0 : out:
2660 0 : if (restore_op)
2661 0 : btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE_PAUSED);
2662 : else
2663 0 : btrfs_exclop_finish(fs_info);
2664 0 : return ret;
2665 : }
2666 :
2667 1 : static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)
2668 : {
2669 1 : BTRFS_DEV_LOOKUP_ARGS(args);
2670 1 : struct inode *inode = file_inode(file);
2671 1 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2672 1 : struct btrfs_ioctl_vol_args_v2 *vol_args;
2673 1 : struct block_device *bdev = NULL;
2674 1 : void *holder;
2675 1 : int ret;
2676 1 : bool cancel = false;
2677 :
2678 1 : if (!capable(CAP_SYS_ADMIN))
2679 : return -EPERM;
2680 :
2681 1 : vol_args = memdup_user(arg, sizeof(*vol_args));
2682 1 : if (IS_ERR(vol_args))
2683 0 : return PTR_ERR(vol_args);
2684 :
2685 1 : if (vol_args->flags & ~BTRFS_DEVICE_REMOVE_ARGS_MASK) {
2686 0 : ret = -EOPNOTSUPP;
2687 0 : goto out;
2688 : }
2689 :
2690 1 : vol_args->name[BTRFS_SUBVOL_NAME_MAX] = '\0';
2691 1 : if (vol_args->flags & BTRFS_DEVICE_SPEC_BY_ID) {
2692 1 : args.devid = vol_args->devid;
2693 0 : } else if (!strcmp("cancel", vol_args->name)) {
2694 : cancel = true;
2695 : } else {
2696 0 : ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);
2697 0 : if (ret)
2698 0 : goto out;
2699 : }
2700 :
2701 1 : ret = mnt_want_write_file(file);
2702 1 : if (ret)
2703 0 : goto out;
2704 :
2705 1 : ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,
2706 : cancel);
2707 1 : if (ret)
2708 0 : goto err_drop;
2709 :
2710 : /* Exclusive operation is now claimed */
2711 1 : ret = btrfs_rm_device(fs_info, &args, &bdev, &holder);
2712 :
2713 1 : btrfs_exclop_finish(fs_info);
2714 :
2715 1 : if (!ret) {
2716 0 : if (vol_args->flags & BTRFS_DEVICE_SPEC_BY_ID)
2717 0 : btrfs_info(fs_info, "device deleted: id %llu",
2718 : vol_args->devid);
2719 : else
2720 0 : btrfs_info(fs_info, "device deleted: %s",
2721 : vol_args->name);
2722 : }
2723 1 : err_drop:
2724 1 : mnt_drop_write_file(file);
2725 1 : if (bdev)
2726 0 : blkdev_put(bdev, holder);
2727 1 : out:
2728 1 : btrfs_put_dev_args_from_path(&args);
2729 1 : kfree(vol_args);
2730 1 : return ret;
2731 : }
2732 :
2733 0 : static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
2734 : {
2735 0 : BTRFS_DEV_LOOKUP_ARGS(args);
2736 0 : struct inode *inode = file_inode(file);
2737 0 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2738 0 : struct btrfs_ioctl_vol_args *vol_args;
2739 0 : struct block_device *bdev = NULL;
2740 0 : void *holder;
2741 0 : int ret;
2742 0 : bool cancel = false;
2743 :
2744 0 : if (!capable(CAP_SYS_ADMIN))
2745 : return -EPERM;
2746 :
2747 0 : vol_args = memdup_user(arg, sizeof(*vol_args));
2748 0 : if (IS_ERR(vol_args))
2749 0 : return PTR_ERR(vol_args);
2750 :
2751 0 : vol_args->name[BTRFS_PATH_NAME_MAX] = '\0';
2752 0 : if (!strcmp("cancel", vol_args->name)) {
2753 : cancel = true;
2754 : } else {
2755 0 : ret = btrfs_get_dev_args_from_path(fs_info, &args, vol_args->name);
2756 0 : if (ret)
2757 0 : goto out;
2758 : }
2759 :
2760 0 : ret = mnt_want_write_file(file);
2761 0 : if (ret)
2762 0 : goto out;
2763 :
2764 0 : ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,
2765 : cancel);
2766 0 : if (ret == 0) {
2767 0 : ret = btrfs_rm_device(fs_info, &args, &bdev, &holder);
2768 0 : if (!ret)
2769 0 : btrfs_info(fs_info, "disk deleted %s", vol_args->name);
2770 0 : btrfs_exclop_finish(fs_info);
2771 : }
2772 :
2773 0 : mnt_drop_write_file(file);
2774 0 : if (bdev)
2775 0 : blkdev_put(bdev, holder);
2776 0 : out:
2777 0 : btrfs_put_dev_args_from_path(&args);
2778 0 : kfree(vol_args);
2779 0 : return ret;
2780 : }
2781 :
2782 629 : static long btrfs_ioctl_fs_info(struct btrfs_fs_info *fs_info,
2783 : void __user *arg)
2784 : {
2785 629 : struct btrfs_ioctl_fs_info_args *fi_args;
2786 629 : struct btrfs_device *device;
2787 629 : struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2788 629 : u64 flags_in;
2789 629 : int ret = 0;
2790 :
2791 629 : fi_args = memdup_user(arg, sizeof(*fi_args));
2792 629 : if (IS_ERR(fi_args))
2793 0 : return PTR_ERR(fi_args);
2794 :
2795 629 : flags_in = fi_args->flags;
2796 629 : memset(fi_args, 0, sizeof(*fi_args));
2797 :
2798 629 : rcu_read_lock();
2799 629 : fi_args->num_devices = fs_devices->num_devices;
2800 :
2801 1261 : list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
2802 632 : if (device->devid > fi_args->max_id)
2803 632 : fi_args->max_id = device->devid;
2804 : }
2805 629 : rcu_read_unlock();
2806 :
2807 1258 : memcpy(&fi_args->fsid, fs_devices->fsid, sizeof(fi_args->fsid));
2808 629 : fi_args->nodesize = fs_info->nodesize;
2809 629 : fi_args->sectorsize = fs_info->sectorsize;
2810 629 : fi_args->clone_alignment = fs_info->sectorsize;
2811 :
2812 629 : if (flags_in & BTRFS_FS_INFO_FLAG_CSUM_INFO) {
2813 12 : fi_args->csum_type = btrfs_super_csum_type(fs_info->super_copy);
2814 12 : fi_args->csum_size = btrfs_super_csum_size(fs_info->super_copy);
2815 12 : fi_args->flags |= BTRFS_FS_INFO_FLAG_CSUM_INFO;
2816 : }
2817 :
2818 629 : if (flags_in & BTRFS_FS_INFO_FLAG_GENERATION) {
2819 9 : fi_args->generation = fs_info->generation;
2820 9 : fi_args->flags |= BTRFS_FS_INFO_FLAG_GENERATION;
2821 : }
2822 :
2823 629 : if (flags_in & BTRFS_FS_INFO_FLAG_METADATA_UUID) {
2824 124 : memcpy(&fi_args->metadata_uuid, fs_devices->metadata_uuid,
2825 : sizeof(fi_args->metadata_uuid));
2826 62 : fi_args->flags |= BTRFS_FS_INFO_FLAG_METADATA_UUID;
2827 : }
2828 :
2829 1258 : if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
2830 : ret = -EFAULT;
2831 :
2832 629 : kfree(fi_args);
2833 629 : return ret;
2834 : }
2835 :
2836 39 : static long btrfs_ioctl_dev_info(struct btrfs_fs_info *fs_info,
2837 : void __user *arg)
2838 : {
2839 39 : BTRFS_DEV_LOOKUP_ARGS(args);
2840 39 : struct btrfs_ioctl_dev_info_args *di_args;
2841 39 : struct btrfs_device *dev;
2842 39 : int ret = 0;
2843 :
2844 39 : di_args = memdup_user(arg, sizeof(*di_args));
2845 39 : if (IS_ERR(di_args))
2846 0 : return PTR_ERR(di_args);
2847 :
2848 39 : args.devid = di_args->devid;
2849 78 : if (!btrfs_is_empty_uuid(di_args->uuid))
2850 0 : args.uuid = di_args->uuid;
2851 :
2852 39 : rcu_read_lock();
2853 39 : dev = btrfs_find_device(fs_info->fs_devices, &args);
2854 39 : if (!dev) {
2855 24 : ret = -ENODEV;
2856 24 : goto out;
2857 : }
2858 :
2859 15 : di_args->devid = dev->devid;
2860 15 : di_args->bytes_used = btrfs_device_get_bytes_used(dev);
2861 15 : di_args->total_bytes = btrfs_device_get_total_bytes(dev);
2862 30 : memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
2863 30 : memcpy(di_args->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
2864 15 : if (dev->name)
2865 15 : strscpy(di_args->path, btrfs_dev_name(dev), sizeof(di_args->path));
2866 : else
2867 0 : di_args->path[0] = '\0';
2868 :
2869 : out:
2870 39 : rcu_read_unlock();
2871 54 : if (ret == 0 && copy_to_user(arg, di_args, sizeof(*di_args)))
2872 : ret = -EFAULT;
2873 :
2874 39 : kfree(di_args);
2875 39 : return ret;
2876 : }
2877 :
2878 6 : static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
2879 : {
2880 6 : struct inode *inode = file_inode(file);
2881 6 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2882 6 : struct btrfs_root *root = BTRFS_I(inode)->root;
2883 6 : struct btrfs_root *new_root;
2884 6 : struct btrfs_dir_item *di;
2885 6 : struct btrfs_trans_handle *trans;
2886 6 : struct btrfs_path *path = NULL;
2887 6 : struct btrfs_disk_key disk_key;
2888 6 : struct fscrypt_str name = FSTR_INIT("default", 7);
2889 6 : u64 objectid = 0;
2890 6 : u64 dir_id;
2891 6 : int ret;
2892 :
2893 6 : if (!capable(CAP_SYS_ADMIN))
2894 : return -EPERM;
2895 :
2896 6 : ret = mnt_want_write_file(file);
2897 6 : if (ret)
2898 0 : return ret;
2899 :
2900 6 : if (copy_from_user(&objectid, argp, sizeof(objectid))) {
2901 0 : ret = -EFAULT;
2902 0 : goto out;
2903 : }
2904 :
2905 6 : if (!objectid)
2906 0 : objectid = BTRFS_FS_TREE_OBJECTID;
2907 :
2908 6 : new_root = btrfs_get_fs_root(fs_info, objectid, true);
2909 6 : if (IS_ERR(new_root)) {
2910 0 : ret = PTR_ERR(new_root);
2911 0 : goto out;
2912 : }
2913 6 : if (!is_fstree(new_root->root_key.objectid)) {
2914 0 : ret = -ENOENT;
2915 0 : goto out_free;
2916 : }
2917 :
2918 6 : path = btrfs_alloc_path();
2919 6 : if (!path) {
2920 0 : ret = -ENOMEM;
2921 0 : goto out_free;
2922 : }
2923 :
2924 6 : trans = btrfs_start_transaction(root, 1);
2925 6 : if (IS_ERR(trans)) {
2926 0 : ret = PTR_ERR(trans);
2927 0 : goto out_free;
2928 : }
2929 :
2930 6 : dir_id = btrfs_super_root_dir(fs_info->super_copy);
2931 6 : di = btrfs_lookup_dir_item(trans, fs_info->tree_root, path,
2932 : dir_id, &name, 1);
2933 12 : if (IS_ERR_OR_NULL(di)) {
2934 0 : btrfs_release_path(path);
2935 0 : btrfs_end_transaction(trans);
2936 0 : btrfs_err(fs_info,
2937 : "Umm, you don't have the default diritem, this isn't going to work");
2938 0 : ret = -ENOENT;
2939 0 : goto out_free;
2940 : }
2941 :
2942 6 : btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
2943 6 : btrfs_set_dir_item_key(path->nodes[0], di, &disk_key);
2944 6 : btrfs_mark_buffer_dirty(path->nodes[0]);
2945 6 : btrfs_release_path(path);
2946 :
2947 6 : btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);
2948 6 : btrfs_end_transaction(trans);
2949 6 : out_free:
2950 6 : btrfs_put_root(new_root);
2951 6 : btrfs_free_path(path);
2952 6 : out:
2953 6 : mnt_drop_write_file(file);
2954 6 : return ret;
2955 : }
2956 :
2957 54 : static void get_block_group_info(struct list_head *groups_list,
2958 : struct btrfs_ioctl_space_info *space)
2959 : {
2960 54 : struct btrfs_block_group *block_group;
2961 :
2962 54 : space->total_bytes = 0;
2963 54 : space->used_bytes = 0;
2964 54 : space->flags = 0;
2965 141 : list_for_each_entry(block_group, groups_list, list) {
2966 87 : space->flags = block_group->flags;
2967 87 : space->total_bytes += block_group->length;
2968 87 : space->used_bytes += block_group->used;
2969 : }
2970 54 : }
2971 :
2972 36 : static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info,
2973 : void __user *arg)
2974 : {
2975 36 : struct btrfs_ioctl_space_args space_args;
2976 36 : struct btrfs_ioctl_space_info space;
2977 36 : struct btrfs_ioctl_space_info *dest;
2978 36 : struct btrfs_ioctl_space_info *dest_orig;
2979 36 : struct btrfs_ioctl_space_info __user *user_dest;
2980 36 : struct btrfs_space_info *info;
2981 36 : static const u64 types[] = {
2982 : BTRFS_BLOCK_GROUP_DATA,
2983 : BTRFS_BLOCK_GROUP_SYSTEM,
2984 : BTRFS_BLOCK_GROUP_METADATA,
2985 : BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA
2986 : };
2987 36 : int num_types = 4;
2988 36 : int alloc_size;
2989 36 : int ret = 0;
2990 36 : u64 slot_count = 0;
2991 36 : int i, c;
2992 :
2993 36 : if (copy_from_user(&space_args,
2994 : (struct btrfs_ioctl_space_args __user *)arg,
2995 : sizeof(space_args)))
2996 : return -EFAULT;
2997 :
2998 180 : for (i = 0; i < num_types; i++) {
2999 144 : struct btrfs_space_info *tmp;
3000 :
3001 144 : info = NULL;
3002 360 : list_for_each_entry(tmp, &fs_info->space_info, list) {
3003 324 : if (tmp->flags == types[i]) {
3004 : info = tmp;
3005 : break;
3006 : }
3007 : }
3008 :
3009 144 : if (!info)
3010 36 : continue;
3011 :
3012 108 : down_read(&info->groups_sem);
3013 1188 : for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3014 972 : if (!list_empty(&info->block_groups[c]))
3015 108 : slot_count++;
3016 : }
3017 108 : up_read(&info->groups_sem);
3018 : }
3019 :
3020 : /*
3021 : * Global block reserve, exported as a space_info
3022 : */
3023 36 : slot_count++;
3024 :
3025 : /* space_slots == 0 means they are asking for a count */
3026 36 : if (space_args.space_slots == 0) {
3027 18 : space_args.total_spaces = slot_count;
3028 18 : goto out;
3029 : }
3030 :
3031 18 : slot_count = min_t(u64, space_args.space_slots, slot_count);
3032 :
3033 18 : alloc_size = sizeof(*dest) * slot_count;
3034 :
3035 : /* we generally have at most 6 or so space infos, one for each raid
3036 : * level. So, a whole page should be more than enough for everyone
3037 : */
3038 18 : if (alloc_size > PAGE_SIZE)
3039 : return -ENOMEM;
3040 :
3041 18 : space_args.total_spaces = 0;
3042 18 : dest = kmalloc(alloc_size, GFP_KERNEL);
3043 18 : if (!dest)
3044 : return -ENOMEM;
3045 : dest_orig = dest;
3046 :
3047 : /* now we have a buffer to copy into */
3048 90 : for (i = 0; i < num_types; i++) {
3049 72 : struct btrfs_space_info *tmp;
3050 :
3051 72 : if (!slot_count)
3052 : break;
3053 :
3054 72 : info = NULL;
3055 180 : list_for_each_entry(tmp, &fs_info->space_info, list) {
3056 162 : if (tmp->flags == types[i]) {
3057 : info = tmp;
3058 : break;
3059 : }
3060 : }
3061 :
3062 72 : if (!info)
3063 18 : continue;
3064 54 : down_read(&info->groups_sem);
3065 594 : for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3066 486 : if (!list_empty(&info->block_groups[c])) {
3067 54 : get_block_group_info(&info->block_groups[c],
3068 : &space);
3069 108 : memcpy(dest, &space, sizeof(space));
3070 54 : dest++;
3071 54 : space_args.total_spaces++;
3072 54 : slot_count--;
3073 : }
3074 486 : if (!slot_count)
3075 : break;
3076 : }
3077 54 : up_read(&info->groups_sem);
3078 : }
3079 :
3080 : /*
3081 : * Add global block reserve
3082 : */
3083 18 : if (slot_count) {
3084 18 : struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
3085 :
3086 18 : spin_lock(&block_rsv->lock);
3087 18 : space.total_bytes = block_rsv->size;
3088 18 : space.used_bytes = block_rsv->size - block_rsv->reserved;
3089 18 : spin_unlock(&block_rsv->lock);
3090 18 : space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV;
3091 36 : memcpy(dest, &space, sizeof(space));
3092 18 : space_args.total_spaces++;
3093 : }
3094 :
3095 18 : user_dest = (struct btrfs_ioctl_space_info __user *)
3096 : (arg + sizeof(struct btrfs_ioctl_space_args));
3097 :
3098 36 : if (copy_to_user(user_dest, dest_orig, alloc_size))
3099 0 : ret = -EFAULT;
3100 :
3101 18 : kfree(dest_orig);
3102 : out:
3103 72 : if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args)))
3104 0 : ret = -EFAULT;
3105 :
3106 36 : return ret;
3107 : }
3108 :
3109 4 : static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
3110 : void __user *argp)
3111 : {
3112 4 : struct btrfs_trans_handle *trans;
3113 4 : u64 transid;
3114 :
3115 : /*
3116 : * Start orphan cleanup here for the given root in case it hasn't been
3117 : * started already by other means. Errors are handled in the other
3118 : * functions during transaction commit.
3119 : */
3120 4 : btrfs_orphan_cleanup(root);
3121 :
3122 4 : trans = btrfs_attach_transaction_barrier(root);
3123 4 : if (IS_ERR(trans)) {
3124 0 : if (PTR_ERR(trans) != -ENOENT)
3125 : return PTR_ERR(trans);
3126 :
3127 : /* No running transaction, don't bother */
3128 0 : transid = root->fs_info->last_trans_committed;
3129 0 : goto out;
3130 : }
3131 4 : transid = trans->transid;
3132 4 : btrfs_commit_transaction_async(trans);
3133 4 : out:
3134 4 : if (argp)
3135 4 : if (copy_to_user(argp, &transid, sizeof(transid)))
3136 0 : return -EFAULT;
3137 : return 0;
3138 : }
3139 :
3140 4 : static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info,
3141 : void __user *argp)
3142 : {
3143 : /* By default wait for the current transaction. */
3144 4 : u64 transid = 0;
3145 :
3146 4 : if (argp)
3147 4 : if (copy_from_user(&transid, argp, sizeof(transid)))
3148 : return -EFAULT;
3149 :
3150 4 : return btrfs_wait_for_commit(fs_info, transid);
3151 : }
3152 :
3153 3 : static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
3154 : {
3155 3 : struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb);
3156 3 : struct btrfs_ioctl_scrub_args *sa;
3157 3 : int ret;
3158 :
3159 3 : if (!capable(CAP_SYS_ADMIN))
3160 : return -EPERM;
3161 :
3162 3 : if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
3163 0 : btrfs_err(fs_info, "scrub is not supported on extent tree v2 yet");
3164 0 : return -EINVAL;
3165 : }
3166 :
3167 3 : sa = memdup_user(arg, sizeof(*sa));
3168 3 : if (IS_ERR(sa))
3169 0 : return PTR_ERR(sa);
3170 :
3171 3 : if (sa->flags & ~BTRFS_SCRUB_SUPPORTED_FLAGS) {
3172 0 : ret = -EOPNOTSUPP;
3173 0 : goto out;
3174 : }
3175 :
3176 3 : if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
3177 3 : ret = mnt_want_write_file(file);
3178 3 : if (ret)
3179 0 : goto out;
3180 : }
3181 :
3182 3 : ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end,
3183 3 : &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
3184 : 0);
3185 :
3186 : /*
3187 : * Copy scrub args to user space even if btrfs_scrub_dev() returned an
3188 : * error. This is important as it allows user space to know how much
3189 : * progress scrub has done. For example, if scrub is canceled we get
3190 : * -ECANCELED from btrfs_scrub_dev() and return that error back to user
3191 : * space. Later user space can inspect the progress from the structure
3192 : * btrfs_ioctl_scrub_args and resume scrub from where it left off
3193 : * previously (btrfs-progs does this).
3194 : * If we fail to copy the btrfs_ioctl_scrub_args structure to user space
3195 : * then return -EFAULT to signal the structure was not copied or it may
3196 : * be corrupt and unreliable due to a partial copy.
3197 : */
3198 6 : if (copy_to_user(arg, sa, sizeof(*sa)))
3199 : ret = -EFAULT;
3200 :
3201 3 : if (!(sa->flags & BTRFS_SCRUB_READONLY))
3202 3 : mnt_drop_write_file(file);
3203 0 : out:
3204 3 : kfree(sa);
3205 3 : return ret;
3206 : }
3207 :
3208 0 : static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info)
3209 : {
3210 0 : if (!capable(CAP_SYS_ADMIN))
3211 : return -EPERM;
3212 :
3213 0 : return btrfs_scrub_cancel(fs_info);
3214 : }
3215 :
3216 9 : static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info,
3217 : void __user *arg)
3218 : {
3219 9 : struct btrfs_ioctl_scrub_args *sa;
3220 9 : int ret;
3221 :
3222 9 : if (!capable(CAP_SYS_ADMIN))
3223 : return -EPERM;
3224 :
3225 9 : sa = memdup_user(arg, sizeof(*sa));
3226 9 : if (IS_ERR(sa))
3227 0 : return PTR_ERR(sa);
3228 :
3229 9 : ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress);
3230 :
3231 13 : if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
3232 : ret = -EFAULT;
3233 :
3234 9 : kfree(sa);
3235 9 : return ret;
3236 : }
3237 :
3238 2 : static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info,
3239 : void __user *arg)
3240 : {
3241 2 : struct btrfs_ioctl_get_dev_stats *sa;
3242 2 : int ret;
3243 :
3244 2 : sa = memdup_user(arg, sizeof(*sa));
3245 2 : if (IS_ERR(sa))
3246 0 : return PTR_ERR(sa);
3247 :
3248 2 : if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) {
3249 0 : kfree(sa);
3250 0 : return -EPERM;
3251 : }
3252 :
3253 2 : ret = btrfs_get_dev_stats(fs_info, sa);
3254 :
3255 4 : if (ret == 0 && copy_to_user(arg, sa, sizeof(*sa)))
3256 : ret = -EFAULT;
3257 :
3258 2 : kfree(sa);
3259 2 : return ret;
3260 : }
3261 :
3262 2 : static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info,
3263 : void __user *arg)
3264 : {
3265 2 : struct btrfs_ioctl_dev_replace_args *p;
3266 2 : int ret;
3267 :
3268 2 : if (!capable(CAP_SYS_ADMIN))
3269 : return -EPERM;
3270 :
3271 2 : if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
3272 0 : btrfs_err(fs_info, "device replace not supported on extent tree v2 yet");
3273 0 : return -EINVAL;
3274 : }
3275 :
3276 2 : p = memdup_user(arg, sizeof(*p));
3277 2 : if (IS_ERR(p))
3278 0 : return PTR_ERR(p);
3279 :
3280 2 : switch (p->cmd) {
3281 1 : case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
3282 1 : if (sb_rdonly(fs_info->sb)) {
3283 1 : ret = -EROFS;
3284 1 : goto out;
3285 : }
3286 0 : if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_DEV_REPLACE)) {
3287 : ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
3288 : } else {
3289 0 : ret = btrfs_dev_replace_by_ioctl(fs_info, p);
3290 0 : btrfs_exclop_finish(fs_info);
3291 : }
3292 : break;
3293 1 : case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
3294 1 : btrfs_dev_replace_status(fs_info, p);
3295 1 : ret = 0;
3296 1 : break;
3297 0 : case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
3298 0 : p->result = btrfs_dev_replace_cancel(fs_info);
3299 0 : ret = 0;
3300 0 : break;
3301 : default:
3302 : ret = -EINVAL;
3303 : break;
3304 : }
3305 :
3306 2 : if ((ret == 0 || ret == -ECANCELED) && copy_to_user(arg, p, sizeof(*p)))
3307 : ret = -EFAULT;
3308 1 : out:
3309 2 : kfree(p);
3310 2 : return ret;
3311 : }
3312 :
3313 779 : static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
3314 : {
3315 779 : int ret = 0;
3316 779 : int i;
3317 779 : u64 rel_ptr;
3318 779 : int size;
3319 779 : struct btrfs_ioctl_ino_path_args *ipa = NULL;
3320 779 : struct inode_fs_paths *ipath = NULL;
3321 779 : struct btrfs_path *path;
3322 :
3323 779 : if (!capable(CAP_DAC_READ_SEARCH))
3324 : return -EPERM;
3325 :
3326 779 : path = btrfs_alloc_path();
3327 779 : if (!path) {
3328 0 : ret = -ENOMEM;
3329 0 : goto out;
3330 : }
3331 :
3332 779 : ipa = memdup_user(arg, sizeof(*ipa));
3333 779 : if (IS_ERR(ipa)) {
3334 0 : ret = PTR_ERR(ipa);
3335 0 : ipa = NULL;
3336 0 : goto out;
3337 : }
3338 :
3339 779 : size = min_t(u32, ipa->size, 4096);
3340 779 : ipath = init_ipath(size, root, path);
3341 779 : if (IS_ERR(ipath)) {
3342 0 : ret = PTR_ERR(ipath);
3343 0 : ipath = NULL;
3344 0 : goto out;
3345 : }
3346 :
3347 779 : ret = paths_from_inode(ipa->inum, ipath);
3348 779 : if (ret < 0)
3349 0 : goto out;
3350 :
3351 1774 : for (i = 0; i < ipath->fspath->elem_cnt; ++i) {
3352 995 : rel_ptr = ipath->fspath->val[i] -
3353 995 : (u64)(unsigned long)ipath->fspath->val;
3354 995 : ipath->fspath->val[i] = rel_ptr;
3355 : }
3356 :
3357 779 : btrfs_free_path(path);
3358 779 : path = NULL;
3359 1558 : ret = copy_to_user((void __user *)(unsigned long)ipa->fspath,
3360 779 : ipath->fspath, size);
3361 779 : if (ret) {
3362 0 : ret = -EFAULT;
3363 0 : goto out;
3364 : }
3365 :
3366 779 : out:
3367 779 : btrfs_free_path(path);
3368 779 : free_ipath(ipath);
3369 779 : kfree(ipa);
3370 :
3371 779 : return ret;
3372 : }
3373 :
3374 796 : static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info,
3375 : void __user *arg, int version)
3376 : {
3377 796 : int ret = 0;
3378 796 : int size;
3379 796 : struct btrfs_ioctl_logical_ino_args *loi;
3380 796 : struct btrfs_data_container *inodes = NULL;
3381 796 : struct btrfs_path *path = NULL;
3382 796 : bool ignore_offset;
3383 :
3384 796 : if (!capable(CAP_SYS_ADMIN))
3385 : return -EPERM;
3386 :
3387 796 : loi = memdup_user(arg, sizeof(*loi));
3388 796 : if (IS_ERR(loi))
3389 0 : return PTR_ERR(loi);
3390 :
3391 796 : if (version == 1) {
3392 789 : ignore_offset = false;
3393 789 : size = min_t(u32, loi->size, SZ_64K);
3394 : } else {
3395 : /* All reserved bits must be 0 for now */
3396 14 : if (memchr_inv(loi->reserved, 0, sizeof(loi->reserved))) {
3397 0 : ret = -EINVAL;
3398 0 : goto out_loi;
3399 : }
3400 : /* Only accept flags we have defined so far */
3401 7 : if (loi->flags & ~(BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET)) {
3402 0 : ret = -EINVAL;
3403 0 : goto out_loi;
3404 : }
3405 7 : ignore_offset = loi->flags & BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET;
3406 7 : size = min_t(u32, loi->size, SZ_16M);
3407 : }
3408 :
3409 796 : inodes = init_data_container(size);
3410 796 : if (IS_ERR(inodes)) {
3411 0 : ret = PTR_ERR(inodes);
3412 0 : goto out_loi;
3413 : }
3414 :
3415 796 : path = btrfs_alloc_path();
3416 796 : if (!path) {
3417 0 : ret = -ENOMEM;
3418 0 : goto out;
3419 : }
3420 796 : ret = iterate_inodes_from_logical(loi->logical, fs_info, path,
3421 : inodes, ignore_offset);
3422 796 : btrfs_free_path(path);
3423 796 : if (ret == -EINVAL)
3424 : ret = -ENOENT;
3425 796 : if (ret < 0)
3426 0 : goto out;
3427 :
3428 796 : ret = copy_to_user((void __user *)(unsigned long)loi->inodes, inodes,
3429 : size);
3430 796 : if (ret)
3431 0 : ret = -EFAULT;
3432 :
3433 796 : out:
3434 796 : kvfree(inodes);
3435 796 : out_loi:
3436 796 : kfree(loi);
3437 :
3438 796 : return ret;
3439 : }
3440 :
3441 191 : void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
3442 : struct btrfs_ioctl_balance_args *bargs)
3443 : {
3444 191 : struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3445 :
3446 191 : bargs->flags = bctl->flags;
3447 :
3448 382 : if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags))
3449 0 : bargs->state |= BTRFS_BALANCE_STATE_RUNNING;
3450 191 : if (atomic_read(&fs_info->balance_pause_req))
3451 0 : bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ;
3452 191 : if (atomic_read(&fs_info->balance_cancel_req))
3453 2 : bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ;
3454 :
3455 382 : memcpy(&bargs->data, &bctl->data, sizeof(bargs->data));
3456 382 : memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta));
3457 382 : memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys));
3458 :
3459 191 : spin_lock(&fs_info->balance_lock);
3460 382 : memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat));
3461 191 : spin_unlock(&fs_info->balance_lock);
3462 191 : }
3463 :
3464 : /*
3465 : * Try to acquire fs_info::balance_mutex as well as set BTRFS_EXLCOP_BALANCE as
3466 : * required.
3467 : *
3468 : * @fs_info: the filesystem
3469 : * @excl_acquired: ptr to boolean value which is set to false in case balance
3470 : * is being resumed
3471 : *
3472 : * Return 0 on success in which case both fs_info::balance is acquired as well
3473 : * as exclusive ops are blocked. In case of failure return an error code.
3474 : */
3475 191 : static int btrfs_try_lock_balance(struct btrfs_fs_info *fs_info, bool *excl_acquired)
3476 : {
3477 191 : int ret;
3478 :
3479 : /*
3480 : * Exclusive operation is locked. Three possibilities:
3481 : * (1) some other op is running
3482 : * (2) balance is running
3483 : * (3) balance is paused -- special case (think resume)
3484 : */
3485 191 : while (1) {
3486 191 : if (btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) {
3487 191 : *excl_acquired = true;
3488 191 : mutex_lock(&fs_info->balance_mutex);
3489 191 : return 0;
3490 : }
3491 :
3492 0 : mutex_lock(&fs_info->balance_mutex);
3493 0 : if (fs_info->balance_ctl) {
3494 : /* This is either (2) or (3) */
3495 0 : if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {
3496 : /* This is (2) */
3497 0 : ret = -EINPROGRESS;
3498 0 : goto out_failure;
3499 :
3500 : } else {
3501 0 : mutex_unlock(&fs_info->balance_mutex);
3502 : /*
3503 : * Lock released to allow other waiters to
3504 : * continue, we'll reexamine the status again.
3505 : */
3506 0 : mutex_lock(&fs_info->balance_mutex);
3507 :
3508 0 : if (fs_info->balance_ctl &&
3509 0 : !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) {
3510 : /* This is (3) */
3511 0 : *excl_acquired = false;
3512 0 : return 0;
3513 : }
3514 : }
3515 : } else {
3516 : /* This is (1) */
3517 0 : ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS;
3518 0 : goto out_failure;
3519 : }
3520 :
3521 0 : mutex_unlock(&fs_info->balance_mutex);
3522 : }
3523 :
3524 0 : out_failure:
3525 0 : mutex_unlock(&fs_info->balance_mutex);
3526 0 : *excl_acquired = false;
3527 0 : return ret;
3528 : }
3529 :
3530 191 : static long btrfs_ioctl_balance(struct file *file, void __user *arg)
3531 : {
3532 191 : struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
3533 191 : struct btrfs_fs_info *fs_info = root->fs_info;
3534 191 : struct btrfs_ioctl_balance_args *bargs;
3535 191 : struct btrfs_balance_control *bctl;
3536 191 : bool need_unlock = true;
3537 191 : int ret;
3538 :
3539 191 : if (!capable(CAP_SYS_ADMIN))
3540 : return -EPERM;
3541 :
3542 191 : ret = mnt_want_write_file(file);
3543 191 : if (ret)
3544 0 : return ret;
3545 :
3546 191 : bargs = memdup_user(arg, sizeof(*bargs));
3547 191 : if (IS_ERR(bargs)) {
3548 0 : ret = PTR_ERR(bargs);
3549 0 : bargs = NULL;
3550 0 : goto out;
3551 : }
3552 :
3553 191 : ret = btrfs_try_lock_balance(fs_info, &need_unlock);
3554 191 : if (ret)
3555 0 : goto out;
3556 :
3557 191 : lockdep_assert_held(&fs_info->balance_mutex);
3558 :
3559 191 : if (bargs->flags & BTRFS_BALANCE_RESUME) {
3560 0 : if (!fs_info->balance_ctl) {
3561 0 : ret = -ENOTCONN;
3562 0 : goto out_unlock;
3563 : }
3564 :
3565 0 : bctl = fs_info->balance_ctl;
3566 0 : spin_lock(&fs_info->balance_lock);
3567 0 : bctl->flags |= BTRFS_BALANCE_RESUME;
3568 0 : spin_unlock(&fs_info->balance_lock);
3569 0 : btrfs_exclop_balance(fs_info, BTRFS_EXCLOP_BALANCE);
3570 :
3571 0 : goto do_balance;
3572 : }
3573 :
3574 191 : if (bargs->flags & ~(BTRFS_BALANCE_ARGS_MASK | BTRFS_BALANCE_TYPE_MASK)) {
3575 0 : ret = -EINVAL;
3576 0 : goto out_unlock;
3577 : }
3578 :
3579 191 : if (fs_info->balance_ctl) {
3580 0 : ret = -EINPROGRESS;
3581 0 : goto out_unlock;
3582 : }
3583 :
3584 191 : bctl = kzalloc(sizeof(*bctl), GFP_KERNEL);
3585 191 : if (!bctl) {
3586 0 : ret = -ENOMEM;
3587 0 : goto out_unlock;
3588 : }
3589 :
3590 382 : memcpy(&bctl->data, &bargs->data, sizeof(bctl->data));
3591 382 : memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta));
3592 382 : memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys));
3593 :
3594 191 : bctl->flags = bargs->flags;
3595 191 : do_balance:
3596 : /*
3597 : * Ownership of bctl and exclusive operation goes to btrfs_balance.
3598 : * bctl is freed in reset_balance_state, or, if restriper was paused
3599 : * all the way until unmount, in free_fs_info. The flag should be
3600 : * cleared after reset_balance_state.
3601 : */
3602 191 : need_unlock = false;
3603 :
3604 191 : ret = btrfs_balance(fs_info, bctl, bargs);
3605 191 : bctl = NULL;
3606 :
3607 191 : if (ret == 0 || ret == -ECANCELED) {
3608 382 : if (copy_to_user(arg, bargs, sizeof(*bargs)))
3609 : ret = -EFAULT;
3610 : }
3611 :
3612 191 : kfree(bctl);
3613 191 : out_unlock:
3614 191 : mutex_unlock(&fs_info->balance_mutex);
3615 191 : if (need_unlock)
3616 0 : btrfs_exclop_finish(fs_info);
3617 191 : out:
3618 191 : mnt_drop_write_file(file);
3619 191 : kfree(bargs);
3620 191 : return ret;
3621 : }
3622 :
3623 12 : static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd)
3624 : {
3625 12 : if (!capable(CAP_SYS_ADMIN))
3626 : return -EPERM;
3627 :
3628 12 : switch (cmd) {
3629 0 : case BTRFS_BALANCE_CTL_PAUSE:
3630 0 : return btrfs_pause_balance(fs_info);
3631 12 : case BTRFS_BALANCE_CTL_CANCEL:
3632 12 : return btrfs_cancel_balance(fs_info);
3633 : }
3634 :
3635 : return -EINVAL;
3636 : }
3637 :
3638 0 : static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info,
3639 : void __user *arg)
3640 : {
3641 0 : struct btrfs_ioctl_balance_args *bargs;
3642 0 : int ret = 0;
3643 :
3644 0 : if (!capable(CAP_SYS_ADMIN))
3645 : return -EPERM;
3646 :
3647 0 : mutex_lock(&fs_info->balance_mutex);
3648 0 : if (!fs_info->balance_ctl) {
3649 0 : ret = -ENOTCONN;
3650 0 : goto out;
3651 : }
3652 :
3653 0 : bargs = kzalloc(sizeof(*bargs), GFP_KERNEL);
3654 0 : if (!bargs) {
3655 0 : ret = -ENOMEM;
3656 0 : goto out;
3657 : }
3658 :
3659 0 : btrfs_update_ioctl_balance_args(fs_info, bargs);
3660 :
3661 0 : if (copy_to_user(arg, bargs, sizeof(*bargs)))
3662 : ret = -EFAULT;
3663 :
3664 0 : kfree(bargs);
3665 0 : out:
3666 0 : mutex_unlock(&fs_info->balance_mutex);
3667 0 : return ret;
3668 : }
3669 :
3670 473 : static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
3671 : {
3672 473 : struct inode *inode = file_inode(file);
3673 473 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
3674 473 : struct btrfs_ioctl_quota_ctl_args *sa;
3675 473 : int ret;
3676 :
3677 473 : if (!capable(CAP_SYS_ADMIN))
3678 : return -EPERM;
3679 :
3680 473 : ret = mnt_want_write_file(file);
3681 473 : if (ret)
3682 0 : return ret;
3683 :
3684 473 : sa = memdup_user(arg, sizeof(*sa));
3685 473 : if (IS_ERR(sa)) {
3686 0 : ret = PTR_ERR(sa);
3687 0 : goto drop_write;
3688 : }
3689 :
3690 473 : down_write(&fs_info->subvol_sem);
3691 :
3692 473 : switch (sa->cmd) {
3693 252 : case BTRFS_QUOTA_CTL_ENABLE:
3694 252 : ret = btrfs_quota_enable(fs_info);
3695 252 : break;
3696 221 : case BTRFS_QUOTA_CTL_DISABLE:
3697 221 : ret = btrfs_quota_disable(fs_info);
3698 221 : break;
3699 : default:
3700 : ret = -EINVAL;
3701 : break;
3702 : }
3703 :
3704 473 : kfree(sa);
3705 473 : up_write(&fs_info->subvol_sem);
3706 473 : drop_write:
3707 473 : mnt_drop_write_file(file);
3708 473 : return ret;
3709 : }
3710 :
3711 6 : static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
3712 : {
3713 6 : struct inode *inode = file_inode(file);
3714 6 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
3715 6 : struct btrfs_root *root = BTRFS_I(inode)->root;
3716 6 : struct btrfs_ioctl_qgroup_assign_args *sa;
3717 6 : struct btrfs_trans_handle *trans;
3718 6 : int ret;
3719 6 : int err;
3720 :
3721 6 : if (!capable(CAP_SYS_ADMIN))
3722 : return -EPERM;
3723 :
3724 6 : ret = mnt_want_write_file(file);
3725 6 : if (ret)
3726 0 : return ret;
3727 :
3728 6 : sa = memdup_user(arg, sizeof(*sa));
3729 6 : if (IS_ERR(sa)) {
3730 0 : ret = PTR_ERR(sa);
3731 0 : goto drop_write;
3732 : }
3733 :
3734 6 : trans = btrfs_join_transaction(root);
3735 6 : if (IS_ERR(trans)) {
3736 0 : ret = PTR_ERR(trans);
3737 0 : goto out;
3738 : }
3739 :
3740 6 : if (sa->assign) {
3741 5 : ret = btrfs_add_qgroup_relation(trans, sa->src, sa->dst);
3742 : } else {
3743 1 : ret = btrfs_del_qgroup_relation(trans, sa->src, sa->dst);
3744 : }
3745 :
3746 : /* update qgroup status and info */
3747 6 : mutex_lock(&fs_info->qgroup_ioctl_lock);
3748 6 : err = btrfs_run_qgroups(trans);
3749 6 : mutex_unlock(&fs_info->qgroup_ioctl_lock);
3750 6 : if (err < 0)
3751 0 : btrfs_handle_fs_error(fs_info, err,
3752 : "failed to update qgroup status and info");
3753 6 : err = btrfs_end_transaction(trans);
3754 6 : if (err && !ret)
3755 0 : ret = err;
3756 :
3757 6 : out:
3758 6 : kfree(sa);
3759 6 : drop_write:
3760 6 : mnt_drop_write_file(file);
3761 6 : return ret;
3762 : }
3763 :
3764 405 : static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
3765 : {
3766 405 : struct inode *inode = file_inode(file);
3767 405 : struct btrfs_root *root = BTRFS_I(inode)->root;
3768 405 : struct btrfs_ioctl_qgroup_create_args *sa;
3769 405 : struct btrfs_trans_handle *trans;
3770 405 : int ret;
3771 405 : int err;
3772 :
3773 405 : if (!capable(CAP_SYS_ADMIN))
3774 : return -EPERM;
3775 :
3776 405 : ret = mnt_want_write_file(file);
3777 405 : if (ret)
3778 0 : return ret;
3779 :
3780 405 : sa = memdup_user(arg, sizeof(*sa));
3781 405 : if (IS_ERR(sa)) {
3782 0 : ret = PTR_ERR(sa);
3783 0 : goto drop_write;
3784 : }
3785 :
3786 405 : if (!sa->qgroupid) {
3787 0 : ret = -EINVAL;
3788 0 : goto out;
3789 : }
3790 :
3791 405 : trans = btrfs_join_transaction(root);
3792 405 : if (IS_ERR(trans)) {
3793 0 : ret = PTR_ERR(trans);
3794 0 : goto out;
3795 : }
3796 :
3797 405 : if (sa->create) {
3798 205 : ret = btrfs_create_qgroup(trans, sa->qgroupid);
3799 : } else {
3800 200 : ret = btrfs_remove_qgroup(trans, sa->qgroupid);
3801 : }
3802 :
3803 405 : err = btrfs_end_transaction(trans);
3804 405 : if (err && !ret)
3805 0 : ret = err;
3806 :
3807 405 : out:
3808 405 : kfree(sa);
3809 405 : drop_write:
3810 405 : mnt_drop_write_file(file);
3811 405 : return ret;
3812 : }
3813 :
3814 11 : static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
3815 : {
3816 11 : struct inode *inode = file_inode(file);
3817 11 : struct btrfs_root *root = BTRFS_I(inode)->root;
3818 11 : struct btrfs_ioctl_qgroup_limit_args *sa;
3819 11 : struct btrfs_trans_handle *trans;
3820 11 : int ret;
3821 11 : int err;
3822 11 : u64 qgroupid;
3823 :
3824 11 : if (!capable(CAP_SYS_ADMIN))
3825 : return -EPERM;
3826 :
3827 11 : ret = mnt_want_write_file(file);
3828 11 : if (ret)
3829 0 : return ret;
3830 :
3831 11 : sa = memdup_user(arg, sizeof(*sa));
3832 11 : if (IS_ERR(sa)) {
3833 0 : ret = PTR_ERR(sa);
3834 0 : goto drop_write;
3835 : }
3836 :
3837 11 : trans = btrfs_join_transaction(root);
3838 11 : if (IS_ERR(trans)) {
3839 0 : ret = PTR_ERR(trans);
3840 0 : goto out;
3841 : }
3842 :
3843 11 : qgroupid = sa->qgroupid;
3844 11 : if (!qgroupid) {
3845 : /* take the current subvol as qgroup */
3846 3 : qgroupid = root->root_key.objectid;
3847 : }
3848 :
3849 11 : ret = btrfs_limit_qgroup(trans, qgroupid, &sa->lim);
3850 :
3851 11 : err = btrfs_end_transaction(trans);
3852 11 : if (err && !ret)
3853 0 : ret = err;
3854 :
3855 11 : out:
3856 11 : kfree(sa);
3857 11 : drop_write:
3858 11 : mnt_drop_write_file(file);
3859 11 : return ret;
3860 : }
3861 :
3862 25 : static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg)
3863 : {
3864 25 : struct inode *inode = file_inode(file);
3865 25 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
3866 25 : struct btrfs_ioctl_quota_rescan_args *qsa;
3867 25 : int ret;
3868 :
3869 25 : if (!capable(CAP_SYS_ADMIN))
3870 : return -EPERM;
3871 :
3872 25 : ret = mnt_want_write_file(file);
3873 25 : if (ret)
3874 0 : return ret;
3875 :
3876 25 : qsa = memdup_user(arg, sizeof(*qsa));
3877 25 : if (IS_ERR(qsa)) {
3878 0 : ret = PTR_ERR(qsa);
3879 0 : goto drop_write;
3880 : }
3881 :
3882 25 : if (qsa->flags) {
3883 0 : ret = -EINVAL;
3884 0 : goto out;
3885 : }
3886 :
3887 25 : ret = btrfs_qgroup_rescan(fs_info);
3888 :
3889 25 : out:
3890 25 : kfree(qsa);
3891 25 : drop_write:
3892 25 : mnt_drop_write_file(file);
3893 25 : return ret;
3894 : }
3895 :
3896 0 : static long btrfs_ioctl_quota_rescan_status(struct btrfs_fs_info *fs_info,
3897 : void __user *arg)
3898 : {
3899 0 : struct btrfs_ioctl_quota_rescan_args qsa = {0};
3900 :
3901 0 : if (!capable(CAP_SYS_ADMIN))
3902 : return -EPERM;
3903 :
3904 0 : if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) {
3905 0 : qsa.flags = 1;
3906 0 : qsa.progress = fs_info->qgroup_rescan_progress.objectid;
3907 : }
3908 :
3909 0 : if (copy_to_user(arg, &qsa, sizeof(qsa)))
3910 0 : return -EFAULT;
3911 :
3912 : return 0;
3913 : }
3914 :
3915 23 : static long btrfs_ioctl_quota_rescan_wait(struct btrfs_fs_info *fs_info,
3916 : void __user *arg)
3917 : {
3918 23 : if (!capable(CAP_SYS_ADMIN))
3919 : return -EPERM;
3920 :
3921 23 : return btrfs_qgroup_wait_for_completion(fs_info, true);
3922 : }
3923 :
3924 195 : static long _btrfs_ioctl_set_received_subvol(struct file *file,
3925 : struct mnt_idmap *idmap,
3926 : struct btrfs_ioctl_received_subvol_args *sa)
3927 : {
3928 195 : struct inode *inode = file_inode(file);
3929 195 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
3930 195 : struct btrfs_root *root = BTRFS_I(inode)->root;
3931 195 : struct btrfs_root_item *root_item = &root->root_item;
3932 195 : struct btrfs_trans_handle *trans;
3933 195 : struct timespec64 ct = current_time(inode);
3934 195 : int ret = 0;
3935 195 : int received_uuid_changed;
3936 :
3937 195 : if (!inode_owner_or_capable(idmap, inode))
3938 : return -EPERM;
3939 :
3940 195 : ret = mnt_want_write_file(file);
3941 195 : if (ret < 0)
3942 0 : return ret;
3943 :
3944 195 : down_write(&fs_info->subvol_sem);
3945 :
3946 195 : if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
3947 0 : ret = -EINVAL;
3948 0 : goto out;
3949 : }
3950 :
3951 195 : if (btrfs_root_readonly(root)) {
3952 0 : ret = -EROFS;
3953 0 : goto out;
3954 : }
3955 :
3956 : /*
3957 : * 1 - root item
3958 : * 2 - uuid items (received uuid + subvol uuid)
3959 : */
3960 195 : trans = btrfs_start_transaction(root, 3);
3961 195 : if (IS_ERR(trans)) {
3962 0 : ret = PTR_ERR(trans);
3963 0 : trans = NULL;
3964 0 : goto out;
3965 : }
3966 :
3967 195 : sa->rtransid = trans->transid;
3968 195 : sa->rtime.sec = ct.tv_sec;
3969 195 : sa->rtime.nsec = ct.tv_nsec;
3970 :
3971 195 : received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid,
3972 : BTRFS_UUID_SIZE);
3973 390 : if (received_uuid_changed &&
3974 : !btrfs_is_empty_uuid(root_item->received_uuid)) {
3975 0 : ret = btrfs_uuid_tree_remove(trans, root_item->received_uuid,
3976 : BTRFS_UUID_KEY_RECEIVED_SUBVOL,
3977 : root->root_key.objectid);
3978 0 : if (ret && ret != -ENOENT) {
3979 0 : btrfs_abort_transaction(trans, ret);
3980 0 : btrfs_end_transaction(trans);
3981 0 : goto out;
3982 : }
3983 : }
3984 390 : memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
3985 195 : btrfs_set_root_stransid(root_item, sa->stransid);
3986 195 : btrfs_set_root_rtransid(root_item, sa->rtransid);
3987 195 : btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec);
3988 195 : btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec);
3989 195 : btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec);
3990 195 : btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec);
3991 :
3992 195 : ret = btrfs_update_root(trans, fs_info->tree_root,
3993 : &root->root_key, &root->root_item);
3994 195 : if (ret < 0) {
3995 0 : btrfs_end_transaction(trans);
3996 0 : goto out;
3997 : }
3998 390 : if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
3999 195 : ret = btrfs_uuid_tree_add(trans, sa->uuid,
4000 : BTRFS_UUID_KEY_RECEIVED_SUBVOL,
4001 : root->root_key.objectid);
4002 195 : if (ret < 0 && ret != -EEXIST) {
4003 0 : btrfs_abort_transaction(trans, ret);
4004 0 : btrfs_end_transaction(trans);
4005 0 : goto out;
4006 : }
4007 : }
4008 195 : ret = btrfs_commit_transaction(trans);
4009 195 : out:
4010 195 : up_write(&fs_info->subvol_sem);
4011 195 : mnt_drop_write_file(file);
4012 195 : return ret;
4013 : }
4014 :
4015 : #ifdef CONFIG_64BIT
4016 0 : static long btrfs_ioctl_set_received_subvol_32(struct file *file,
4017 : void __user *arg)
4018 : {
4019 0 : struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL;
4020 0 : struct btrfs_ioctl_received_subvol_args *args64 = NULL;
4021 0 : int ret = 0;
4022 :
4023 0 : args32 = memdup_user(arg, sizeof(*args32));
4024 0 : if (IS_ERR(args32))
4025 0 : return PTR_ERR(args32);
4026 :
4027 0 : args64 = kmalloc(sizeof(*args64), GFP_KERNEL);
4028 0 : if (!args64) {
4029 0 : ret = -ENOMEM;
4030 0 : goto out;
4031 : }
4032 :
4033 0 : memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE);
4034 0 : args64->stransid = args32->stransid;
4035 0 : args64->rtransid = args32->rtransid;
4036 0 : args64->stime.sec = args32->stime.sec;
4037 0 : args64->stime.nsec = args32->stime.nsec;
4038 0 : args64->rtime.sec = args32->rtime.sec;
4039 0 : args64->rtime.nsec = args32->rtime.nsec;
4040 0 : args64->flags = args32->flags;
4041 :
4042 0 : ret = _btrfs_ioctl_set_received_subvol(file, file_mnt_idmap(file), args64);
4043 0 : if (ret)
4044 0 : goto out;
4045 :
4046 0 : memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE);
4047 0 : args32->stransid = args64->stransid;
4048 0 : args32->rtransid = args64->rtransid;
4049 0 : args32->stime.sec = args64->stime.sec;
4050 0 : args32->stime.nsec = args64->stime.nsec;
4051 0 : args32->rtime.sec = args64->rtime.sec;
4052 0 : args32->rtime.nsec = args64->rtime.nsec;
4053 0 : args32->flags = args64->flags;
4054 :
4055 0 : ret = copy_to_user(arg, args32, sizeof(*args32));
4056 0 : if (ret)
4057 0 : ret = -EFAULT;
4058 :
4059 0 : out:
4060 0 : kfree(args32);
4061 0 : kfree(args64);
4062 0 : return ret;
4063 : }
4064 : #endif
4065 :
4066 195 : static long btrfs_ioctl_set_received_subvol(struct file *file,
4067 : void __user *arg)
4068 : {
4069 195 : struct btrfs_ioctl_received_subvol_args *sa = NULL;
4070 195 : int ret = 0;
4071 :
4072 195 : sa = memdup_user(arg, sizeof(*sa));
4073 195 : if (IS_ERR(sa))
4074 0 : return PTR_ERR(sa);
4075 :
4076 195 : ret = _btrfs_ioctl_set_received_subvol(file, file_mnt_idmap(file), sa);
4077 :
4078 195 : if (ret)
4079 0 : goto out;
4080 :
4081 195 : ret = copy_to_user(arg, sa, sizeof(*sa));
4082 195 : if (ret)
4083 0 : ret = -EFAULT;
4084 :
4085 195 : out:
4086 195 : kfree(sa);
4087 195 : return ret;
4088 : }
4089 :
4090 11 : static int btrfs_ioctl_get_fslabel(struct btrfs_fs_info *fs_info,
4091 : void __user *arg)
4092 : {
4093 11 : size_t len;
4094 11 : int ret;
4095 11 : char label[BTRFS_LABEL_SIZE];
4096 :
4097 11 : spin_lock(&fs_info->super_lock);
4098 11 : memcpy(label, fs_info->super_copy->label, BTRFS_LABEL_SIZE);
4099 11 : spin_unlock(&fs_info->super_lock);
4100 :
4101 11 : len = strnlen(label, BTRFS_LABEL_SIZE);
4102 :
4103 11 : if (len == BTRFS_LABEL_SIZE) {
4104 0 : btrfs_warn(fs_info,
4105 : "label is too long, return the first %zu bytes",
4106 : --len);
4107 : }
4108 :
4109 11 : ret = copy_to_user(arg, label, len);
4110 :
4111 11 : return ret ? -EFAULT : 0;
4112 : }
4113 :
4114 7 : static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
4115 : {
4116 7 : struct inode *inode = file_inode(file);
4117 7 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
4118 7 : struct btrfs_root *root = BTRFS_I(inode)->root;
4119 7 : struct btrfs_super_block *super_block = fs_info->super_copy;
4120 7 : struct btrfs_trans_handle *trans;
4121 7 : char label[BTRFS_LABEL_SIZE];
4122 7 : int ret;
4123 :
4124 7 : if (!capable(CAP_SYS_ADMIN))
4125 : return -EPERM;
4126 :
4127 7 : if (copy_from_user(label, arg, sizeof(label)))
4128 : return -EFAULT;
4129 :
4130 14 : if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) {
4131 1 : btrfs_err(fs_info,
4132 : "unable to set label with more than %d bytes",
4133 : BTRFS_LABEL_SIZE - 1);
4134 1 : return -EINVAL;
4135 : }
4136 :
4137 6 : ret = mnt_want_write_file(file);
4138 6 : if (ret)
4139 : return ret;
4140 :
4141 6 : trans = btrfs_start_transaction(root, 0);
4142 6 : if (IS_ERR(trans)) {
4143 0 : ret = PTR_ERR(trans);
4144 0 : goto out_unlock;
4145 : }
4146 :
4147 6 : spin_lock(&fs_info->super_lock);
4148 6 : strcpy(super_block->label, label);
4149 6 : spin_unlock(&fs_info->super_lock);
4150 6 : ret = btrfs_commit_transaction(trans);
4151 :
4152 6 : out_unlock:
4153 6 : mnt_drop_write_file(file);
4154 6 : return ret;
4155 : }
4156 :
4157 : #define INIT_FEATURE_FLAGS(suffix) \
4158 : { .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \
4159 : .compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \
4160 : .incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix }
4161 :
4162 0 : int btrfs_ioctl_get_supported_features(void __user *arg)
4163 : {
4164 0 : static const struct btrfs_ioctl_feature_flags features[3] = {
4165 : INIT_FEATURE_FLAGS(SUPP),
4166 : INIT_FEATURE_FLAGS(SAFE_SET),
4167 : INIT_FEATURE_FLAGS(SAFE_CLEAR)
4168 : };
4169 :
4170 0 : if (copy_to_user(arg, &features, sizeof(features)))
4171 0 : return -EFAULT;
4172 :
4173 : return 0;
4174 : }
4175 :
4176 1 : static int btrfs_ioctl_get_features(struct btrfs_fs_info *fs_info,
4177 : void __user *arg)
4178 : {
4179 1 : struct btrfs_super_block *super_block = fs_info->super_copy;
4180 1 : struct btrfs_ioctl_feature_flags features;
4181 :
4182 1 : features.compat_flags = btrfs_super_compat_flags(super_block);
4183 1 : features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block);
4184 1 : features.incompat_flags = btrfs_super_incompat_flags(super_block);
4185 :
4186 1 : if (copy_to_user(arg, &features, sizeof(features)))
4187 0 : return -EFAULT;
4188 :
4189 : return 0;
4190 : }
4191 :
4192 0 : static int check_feature_bits(struct btrfs_fs_info *fs_info,
4193 : enum btrfs_feature_set set,
4194 : u64 change_mask, u64 flags, u64 supported_flags,
4195 : u64 safe_set, u64 safe_clear)
4196 : {
4197 0 : const char *type = btrfs_feature_set_name(set);
4198 0 : char *names;
4199 0 : u64 disallowed, unsupported;
4200 0 : u64 set_mask = flags & change_mask;
4201 0 : u64 clear_mask = ~flags & change_mask;
4202 :
4203 0 : unsupported = set_mask & ~supported_flags;
4204 0 : if (unsupported) {
4205 0 : names = btrfs_printable_features(set, unsupported);
4206 0 : if (names) {
4207 0 : btrfs_warn(fs_info,
4208 : "this kernel does not support the %s feature bit%s",
4209 : names, strchr(names, ',') ? "s" : "");
4210 0 : kfree(names);
4211 : } else
4212 0 : btrfs_warn(fs_info,
4213 : "this kernel does not support %s bits 0x%llx",
4214 : type, unsupported);
4215 0 : return -EOPNOTSUPP;
4216 : }
4217 :
4218 0 : disallowed = set_mask & ~safe_set;
4219 0 : if (disallowed) {
4220 0 : names = btrfs_printable_features(set, disallowed);
4221 0 : if (names) {
4222 0 : btrfs_warn(fs_info,
4223 : "can't set the %s feature bit%s while mounted",
4224 : names, strchr(names, ',') ? "s" : "");
4225 0 : kfree(names);
4226 : } else
4227 0 : btrfs_warn(fs_info,
4228 : "can't set %s bits 0x%llx while mounted",
4229 : type, disallowed);
4230 0 : return -EPERM;
4231 : }
4232 :
4233 0 : disallowed = clear_mask & ~safe_clear;
4234 0 : if (disallowed) {
4235 0 : names = btrfs_printable_features(set, disallowed);
4236 0 : if (names) {
4237 0 : btrfs_warn(fs_info,
4238 : "can't clear the %s feature bit%s while mounted",
4239 : names, strchr(names, ',') ? "s" : "");
4240 0 : kfree(names);
4241 : } else
4242 0 : btrfs_warn(fs_info,
4243 : "can't clear %s bits 0x%llx while mounted",
4244 : type, disallowed);
4245 0 : return -EPERM;
4246 : }
4247 :
4248 : return 0;
4249 : }
4250 :
4251 : #define check_feature(fs_info, change_mask, flags, mask_base) \
4252 : check_feature_bits(fs_info, FEAT_##mask_base, change_mask, flags, \
4253 : BTRFS_FEATURE_ ## mask_base ## _SUPP, \
4254 : BTRFS_FEATURE_ ## mask_base ## _SAFE_SET, \
4255 : BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR)
4256 :
4257 0 : static int btrfs_ioctl_set_features(struct file *file, void __user *arg)
4258 : {
4259 0 : struct inode *inode = file_inode(file);
4260 0 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
4261 0 : struct btrfs_root *root = BTRFS_I(inode)->root;
4262 0 : struct btrfs_super_block *super_block = fs_info->super_copy;
4263 0 : struct btrfs_ioctl_feature_flags flags[2];
4264 0 : struct btrfs_trans_handle *trans;
4265 0 : u64 newflags;
4266 0 : int ret;
4267 :
4268 0 : if (!capable(CAP_SYS_ADMIN))
4269 : return -EPERM;
4270 :
4271 0 : if (copy_from_user(flags, arg, sizeof(flags)))
4272 : return -EFAULT;
4273 :
4274 : /* Nothing to do */
4275 0 : if (!flags[0].compat_flags && !flags[0].compat_ro_flags &&
4276 0 : !flags[0].incompat_flags)
4277 : return 0;
4278 :
4279 0 : ret = check_feature(fs_info, flags[0].compat_flags,
4280 : flags[1].compat_flags, COMPAT);
4281 0 : if (ret)
4282 : return ret;
4283 :
4284 0 : ret = check_feature(fs_info, flags[0].compat_ro_flags,
4285 : flags[1].compat_ro_flags, COMPAT_RO);
4286 0 : if (ret)
4287 : return ret;
4288 :
4289 0 : ret = check_feature(fs_info, flags[0].incompat_flags,
4290 : flags[1].incompat_flags, INCOMPAT);
4291 0 : if (ret)
4292 : return ret;
4293 :
4294 0 : ret = mnt_want_write_file(file);
4295 0 : if (ret)
4296 : return ret;
4297 :
4298 0 : trans = btrfs_start_transaction(root, 0);
4299 0 : if (IS_ERR(trans)) {
4300 0 : ret = PTR_ERR(trans);
4301 0 : goto out_drop_write;
4302 : }
4303 :
4304 0 : spin_lock(&fs_info->super_lock);
4305 0 : newflags = btrfs_super_compat_flags(super_block);
4306 0 : newflags |= flags[0].compat_flags & flags[1].compat_flags;
4307 0 : newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags);
4308 0 : btrfs_set_super_compat_flags(super_block, newflags);
4309 :
4310 0 : newflags = btrfs_super_compat_ro_flags(super_block);
4311 0 : newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags;
4312 0 : newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags);
4313 0 : btrfs_set_super_compat_ro_flags(super_block, newflags);
4314 :
4315 0 : newflags = btrfs_super_incompat_flags(super_block);
4316 0 : newflags |= flags[0].incompat_flags & flags[1].incompat_flags;
4317 0 : newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags);
4318 0 : btrfs_set_super_incompat_flags(super_block, newflags);
4319 0 : spin_unlock(&fs_info->super_lock);
4320 :
4321 0 : ret = btrfs_commit_transaction(trans);
4322 0 : out_drop_write:
4323 0 : mnt_drop_write_file(file);
4324 :
4325 0 : return ret;
4326 : }
4327 :
4328 213 : static int _btrfs_ioctl_send(struct inode *inode, void __user *argp, bool compat)
4329 : {
4330 213 : struct btrfs_ioctl_send_args *arg;
4331 213 : int ret;
4332 :
4333 213 : if (compat) {
4334 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4335 0 : struct btrfs_ioctl_send_args_32 args32;
4336 :
4337 0 : ret = copy_from_user(&args32, argp, sizeof(args32));
4338 0 : if (ret)
4339 0 : return -EFAULT;
4340 0 : arg = kzalloc(sizeof(*arg), GFP_KERNEL);
4341 0 : if (!arg)
4342 : return -ENOMEM;
4343 0 : arg->send_fd = args32.send_fd;
4344 0 : arg->clone_sources_count = args32.clone_sources_count;
4345 0 : arg->clone_sources = compat_ptr(args32.clone_sources);
4346 0 : arg->parent_root = args32.parent_root;
4347 0 : arg->flags = args32.flags;
4348 0 : memcpy(arg->reserved, args32.reserved,
4349 : sizeof(args32.reserved));
4350 : #else
4351 : return -ENOTTY;
4352 : #endif
4353 : } else {
4354 213 : arg = memdup_user(argp, sizeof(*arg));
4355 213 : if (IS_ERR(arg))
4356 0 : return PTR_ERR(arg);
4357 : }
4358 213 : ret = btrfs_ioctl_send(inode, arg);
4359 213 : kfree(arg);
4360 213 : return ret;
4361 : }
4362 :
4363 0 : static int btrfs_ioctl_encoded_read(struct file *file, void __user *argp,
4364 : bool compat)
4365 : {
4366 0 : struct btrfs_ioctl_encoded_io_args args = { 0 };
4367 0 : size_t copy_end_kernel = offsetofend(struct btrfs_ioctl_encoded_io_args,
4368 : flags);
4369 0 : size_t copy_end;
4370 0 : struct iovec iovstack[UIO_FASTIOV];
4371 0 : struct iovec *iov = iovstack;
4372 0 : struct iov_iter iter;
4373 0 : loff_t pos;
4374 0 : struct kiocb kiocb;
4375 0 : ssize_t ret;
4376 :
4377 0 : if (!capable(CAP_SYS_ADMIN)) {
4378 0 : ret = -EPERM;
4379 0 : goto out_acct;
4380 : }
4381 :
4382 0 : if (compat) {
4383 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4384 0 : struct btrfs_ioctl_encoded_io_args_32 args32;
4385 :
4386 0 : copy_end = offsetofend(struct btrfs_ioctl_encoded_io_args_32,
4387 : flags);
4388 0 : if (copy_from_user(&args32, argp, copy_end)) {
4389 0 : ret = -EFAULT;
4390 0 : goto out_acct;
4391 : }
4392 0 : args.iov = compat_ptr(args32.iov);
4393 0 : args.iovcnt = args32.iovcnt;
4394 0 : args.offset = args32.offset;
4395 0 : args.flags = args32.flags;
4396 : #else
4397 : return -ENOTTY;
4398 : #endif
4399 : } else {
4400 0 : copy_end = copy_end_kernel;
4401 0 : if (copy_from_user(&args, argp, copy_end)) {
4402 0 : ret = -EFAULT;
4403 0 : goto out_acct;
4404 : }
4405 : }
4406 0 : if (args.flags != 0) {
4407 0 : ret = -EINVAL;
4408 0 : goto out_acct;
4409 : }
4410 :
4411 0 : ret = import_iovec(ITER_DEST, args.iov, args.iovcnt, ARRAY_SIZE(iovstack),
4412 : &iov, &iter);
4413 0 : if (ret < 0)
4414 0 : goto out_acct;
4415 :
4416 0 : if (iov_iter_count(&iter) == 0) {
4417 0 : ret = 0;
4418 0 : goto out_iov;
4419 : }
4420 0 : pos = args.offset;
4421 0 : ret = rw_verify_area(READ, file, &pos, args.len);
4422 0 : if (ret < 0)
4423 0 : goto out_iov;
4424 :
4425 0 : init_sync_kiocb(&kiocb, file);
4426 0 : kiocb.ki_pos = pos;
4427 :
4428 0 : ret = btrfs_encoded_read(&kiocb, &iter, &args);
4429 0 : if (ret >= 0) {
4430 0 : fsnotify_access(file);
4431 0 : if (copy_to_user(argp + copy_end,
4432 : (char *)&args + copy_end_kernel,
4433 : sizeof(args) - copy_end_kernel))
4434 0 : ret = -EFAULT;
4435 : }
4436 :
4437 0 : out_iov:
4438 0 : kfree(iov);
4439 0 : out_acct:
4440 0 : if (ret > 0)
4441 0 : add_rchar(current, ret);
4442 0 : inc_syscr(current);
4443 0 : return ret;
4444 : }
4445 :
4446 0 : static int btrfs_ioctl_encoded_write(struct file *file, void __user *argp, bool compat)
4447 : {
4448 0 : struct btrfs_ioctl_encoded_io_args args;
4449 0 : struct iovec iovstack[UIO_FASTIOV];
4450 0 : struct iovec *iov = iovstack;
4451 0 : struct iov_iter iter;
4452 0 : loff_t pos;
4453 0 : struct kiocb kiocb;
4454 0 : ssize_t ret;
4455 :
4456 0 : if (!capable(CAP_SYS_ADMIN)) {
4457 0 : ret = -EPERM;
4458 0 : goto out_acct;
4459 : }
4460 :
4461 0 : if (!(file->f_mode & FMODE_WRITE)) {
4462 0 : ret = -EBADF;
4463 0 : goto out_acct;
4464 : }
4465 :
4466 0 : if (compat) {
4467 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4468 0 : struct btrfs_ioctl_encoded_io_args_32 args32;
4469 :
4470 0 : if (copy_from_user(&args32, argp, sizeof(args32))) {
4471 0 : ret = -EFAULT;
4472 0 : goto out_acct;
4473 : }
4474 0 : args.iov = compat_ptr(args32.iov);
4475 0 : args.iovcnt = args32.iovcnt;
4476 0 : args.offset = args32.offset;
4477 0 : args.flags = args32.flags;
4478 0 : args.len = args32.len;
4479 0 : args.unencoded_len = args32.unencoded_len;
4480 0 : args.unencoded_offset = args32.unencoded_offset;
4481 0 : args.compression = args32.compression;
4482 0 : args.encryption = args32.encryption;
4483 0 : memcpy(args.reserved, args32.reserved, sizeof(args.reserved));
4484 : #else
4485 : return -ENOTTY;
4486 : #endif
4487 : } else {
4488 0 : if (copy_from_user(&args, argp, sizeof(args))) {
4489 0 : ret = -EFAULT;
4490 0 : goto out_acct;
4491 : }
4492 : }
4493 :
4494 0 : ret = -EINVAL;
4495 0 : if (args.flags != 0)
4496 0 : goto out_acct;
4497 0 : if (memchr_inv(args.reserved, 0, sizeof(args.reserved)))
4498 0 : goto out_acct;
4499 0 : if (args.compression == BTRFS_ENCODED_IO_COMPRESSION_NONE &&
4500 : args.encryption == BTRFS_ENCODED_IO_ENCRYPTION_NONE)
4501 0 : goto out_acct;
4502 0 : if (args.compression >= BTRFS_ENCODED_IO_COMPRESSION_TYPES ||
4503 0 : args.encryption >= BTRFS_ENCODED_IO_ENCRYPTION_TYPES)
4504 0 : goto out_acct;
4505 0 : if (args.unencoded_offset > args.unencoded_len)
4506 0 : goto out_acct;
4507 0 : if (args.len > args.unencoded_len - args.unencoded_offset)
4508 0 : goto out_acct;
4509 :
4510 0 : ret = import_iovec(ITER_SOURCE, args.iov, args.iovcnt, ARRAY_SIZE(iovstack),
4511 : &iov, &iter);
4512 0 : if (ret < 0)
4513 0 : goto out_acct;
4514 :
4515 0 : file_start_write(file);
4516 :
4517 0 : if (iov_iter_count(&iter) == 0) {
4518 0 : ret = 0;
4519 0 : goto out_end_write;
4520 : }
4521 0 : pos = args.offset;
4522 0 : ret = rw_verify_area(WRITE, file, &pos, args.len);
4523 0 : if (ret < 0)
4524 0 : goto out_end_write;
4525 :
4526 0 : init_sync_kiocb(&kiocb, file);
4527 0 : ret = kiocb_set_rw_flags(&kiocb, 0);
4528 0 : if (ret)
4529 : goto out_end_write;
4530 0 : kiocb.ki_pos = pos;
4531 :
4532 0 : ret = btrfs_do_write_iter(&kiocb, &iter, &args);
4533 0 : if (ret > 0)
4534 0 : fsnotify_modify(file);
4535 :
4536 0 : out_end_write:
4537 0 : file_end_write(file);
4538 0 : kfree(iov);
4539 0 : out_acct:
4540 0 : if (ret > 0)
4541 0 : add_wchar(current, ret);
4542 0 : inc_syscw(current);
4543 0 : return ret;
4544 : }
4545 :
4546 109269 : long btrfs_ioctl(struct file *file, unsigned int
4547 : cmd, unsigned long arg)
4548 : {
4549 109269 : struct inode *inode = file_inode(file);
4550 109269 : struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
4551 109269 : struct btrfs_root *root = BTRFS_I(inode)->root;
4552 109269 : void __user *argp = (void __user *)arg;
4553 :
4554 109269 : switch (cmd) {
4555 : case FS_IOC_GETVERSION:
4556 0 : return btrfs_ioctl_getversion(inode, argp);
4557 11 : case FS_IOC_GETFSLABEL:
4558 11 : return btrfs_ioctl_get_fslabel(fs_info, argp);
4559 7 : case FS_IOC_SETFSLABEL:
4560 7 : return btrfs_ioctl_set_fslabel(file, argp);
4561 851 : case FITRIM:
4562 851 : return btrfs_ioctl_fitrim(fs_info, argp);
4563 0 : case BTRFS_IOC_SNAP_CREATE:
4564 0 : return btrfs_ioctl_snap_create(file, argp, 0);
4565 1033 : case BTRFS_IOC_SNAP_CREATE_V2:
4566 1033 : return btrfs_ioctl_snap_create_v2(file, argp, 0);
4567 213 : case BTRFS_IOC_SUBVOL_CREATE:
4568 213 : return btrfs_ioctl_snap_create(file, argp, 1);
4569 43 : case BTRFS_IOC_SUBVOL_CREATE_V2:
4570 43 : return btrfs_ioctl_snap_create_v2(file, argp, 1);
4571 160 : case BTRFS_IOC_SNAP_DESTROY:
4572 160 : return btrfs_ioctl_snap_destroy(file, argp, false);
4573 6 : case BTRFS_IOC_SNAP_DESTROY_V2:
4574 6 : return btrfs_ioctl_snap_destroy(file, argp, true);
4575 601 : case BTRFS_IOC_SUBVOL_GETFLAGS:
4576 601 : return btrfs_ioctl_subvol_getflags(inode, argp);
4577 224 : case BTRFS_IOC_SUBVOL_SETFLAGS:
4578 224 : return btrfs_ioctl_subvol_setflags(file, argp);
4579 6 : case BTRFS_IOC_DEFAULT_SUBVOL:
4580 6 : return btrfs_ioctl_default_subvol(file, argp);
4581 0 : case BTRFS_IOC_DEFRAG:
4582 0 : return btrfs_ioctl_defrag(file, NULL);
4583 189 : case BTRFS_IOC_DEFRAG_RANGE:
4584 189 : return btrfs_ioctl_defrag(file, argp);
4585 4 : case BTRFS_IOC_RESIZE:
4586 4 : return btrfs_ioctl_resize(file, argp);
4587 0 : case BTRFS_IOC_ADD_DEV:
4588 0 : return btrfs_ioctl_add_dev(fs_info, argp);
4589 0 : case BTRFS_IOC_RM_DEV:
4590 0 : return btrfs_ioctl_rm_dev(file, argp);
4591 1 : case BTRFS_IOC_RM_DEV_V2:
4592 1 : return btrfs_ioctl_rm_dev_v2(file, argp);
4593 629 : case BTRFS_IOC_FS_INFO:
4594 629 : return btrfs_ioctl_fs_info(fs_info, argp);
4595 39 : case BTRFS_IOC_DEV_INFO:
4596 39 : return btrfs_ioctl_dev_info(fs_info, argp);
4597 9229 : case BTRFS_IOC_TREE_SEARCH:
4598 9229 : return btrfs_ioctl_tree_search(inode, argp);
4599 0 : case BTRFS_IOC_TREE_SEARCH_V2:
4600 0 : return btrfs_ioctl_tree_search_v2(inode, argp);
4601 4921 : case BTRFS_IOC_INO_LOOKUP:
4602 4921 : return btrfs_ioctl_ino_lookup(root, argp);
4603 779 : case BTRFS_IOC_INO_PATHS:
4604 779 : return btrfs_ioctl_ino_to_path(root, argp);
4605 789 : case BTRFS_IOC_LOGICAL_INO:
4606 789 : return btrfs_ioctl_logical_to_ino(fs_info, argp, 1);
4607 7 : case BTRFS_IOC_LOGICAL_INO_V2:
4608 7 : return btrfs_ioctl_logical_to_ino(fs_info, argp, 2);
4609 36 : case BTRFS_IOC_SPACE_INFO:
4610 36 : return btrfs_ioctl_space_info(fs_info, argp);
4611 326 : case BTRFS_IOC_SYNC: {
4612 326 : int ret;
4613 :
4614 326 : ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);
4615 326 : if (ret)
4616 0 : return ret;
4617 326 : ret = btrfs_sync_fs(inode->i_sb, 1);
4618 : /*
4619 : * The transaction thread may want to do more work,
4620 : * namely it pokes the cleaner kthread that will start
4621 : * processing uncleaned subvols.
4622 : */
4623 326 : wake_up_process(fs_info->transaction_kthread);
4624 326 : return ret;
4625 : }
4626 4 : case BTRFS_IOC_START_SYNC:
4627 4 : return btrfs_ioctl_start_sync(root, argp);
4628 4 : case BTRFS_IOC_WAIT_SYNC:
4629 4 : return btrfs_ioctl_wait_sync(fs_info, argp);
4630 3 : case BTRFS_IOC_SCRUB:
4631 3 : return btrfs_ioctl_scrub(file, argp);
4632 0 : case BTRFS_IOC_SCRUB_CANCEL:
4633 0 : return btrfs_ioctl_scrub_cancel(fs_info);
4634 9 : case BTRFS_IOC_SCRUB_PROGRESS:
4635 9 : return btrfs_ioctl_scrub_progress(fs_info, argp);
4636 191 : case BTRFS_IOC_BALANCE_V2:
4637 191 : return btrfs_ioctl_balance(file, argp);
4638 12 : case BTRFS_IOC_BALANCE_CTL:
4639 12 : return btrfs_ioctl_balance_ctl(fs_info, arg);
4640 0 : case BTRFS_IOC_BALANCE_PROGRESS:
4641 0 : return btrfs_ioctl_balance_progress(fs_info, argp);
4642 195 : case BTRFS_IOC_SET_RECEIVED_SUBVOL:
4643 195 : return btrfs_ioctl_set_received_subvol(file, argp);
4644 : #ifdef CONFIG_64BIT
4645 0 : case BTRFS_IOC_SET_RECEIVED_SUBVOL_32:
4646 0 : return btrfs_ioctl_set_received_subvol_32(file, argp);
4647 : #endif
4648 213 : case BTRFS_IOC_SEND:
4649 213 : return _btrfs_ioctl_send(inode, argp, false);
4650 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4651 0 : case BTRFS_IOC_SEND_32:
4652 0 : return _btrfs_ioctl_send(inode, argp, true);
4653 : #endif
4654 2 : case BTRFS_IOC_GET_DEV_STATS:
4655 2 : return btrfs_ioctl_get_dev_stats(fs_info, argp);
4656 473 : case BTRFS_IOC_QUOTA_CTL:
4657 473 : return btrfs_ioctl_quota_ctl(file, argp);
4658 6 : case BTRFS_IOC_QGROUP_ASSIGN:
4659 6 : return btrfs_ioctl_qgroup_assign(file, argp);
4660 405 : case BTRFS_IOC_QGROUP_CREATE:
4661 405 : return btrfs_ioctl_qgroup_create(file, argp);
4662 11 : case BTRFS_IOC_QGROUP_LIMIT:
4663 11 : return btrfs_ioctl_qgroup_limit(file, argp);
4664 25 : case BTRFS_IOC_QUOTA_RESCAN:
4665 25 : return btrfs_ioctl_quota_rescan(file, argp);
4666 0 : case BTRFS_IOC_QUOTA_RESCAN_STATUS:
4667 0 : return btrfs_ioctl_quota_rescan_status(fs_info, argp);
4668 23 : case BTRFS_IOC_QUOTA_RESCAN_WAIT:
4669 23 : return btrfs_ioctl_quota_rescan_wait(fs_info, argp);
4670 2 : case BTRFS_IOC_DEV_REPLACE:
4671 2 : return btrfs_ioctl_dev_replace(fs_info, argp);
4672 0 : case BTRFS_IOC_GET_SUPPORTED_FEATURES:
4673 0 : return btrfs_ioctl_get_supported_features(argp);
4674 1 : case BTRFS_IOC_GET_FEATURES:
4675 1 : return btrfs_ioctl_get_features(fs_info, argp);
4676 0 : case BTRFS_IOC_SET_FEATURES:
4677 0 : return btrfs_ioctl_set_features(file, argp);
4678 0 : case BTRFS_IOC_GET_SUBVOL_INFO:
4679 0 : return btrfs_ioctl_get_subvol_info(inode, argp);
4680 12 : case BTRFS_IOC_GET_SUBVOL_ROOTREF:
4681 12 : return btrfs_ioctl_get_subvol_rootref(root, argp);
4682 8 : case BTRFS_IOC_INO_LOOKUP_USER:
4683 8 : return btrfs_ioctl_ino_lookup_user(file, argp);
4684 : case FS_IOC_ENABLE_VERITY:
4685 : return fsverity_ioctl_enable(file, (const void __user *)argp);
4686 : case FS_IOC_MEASURE_VERITY:
4687 : return fsverity_ioctl_measure(file, argp);
4688 0 : case BTRFS_IOC_ENCODED_READ:
4689 0 : return btrfs_ioctl_encoded_read(file, argp, false);
4690 0 : case BTRFS_IOC_ENCODED_WRITE:
4691 0 : return btrfs_ioctl_encoded_write(file, argp, false);
4692 : #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT)
4693 0 : case BTRFS_IOC_ENCODED_READ_32:
4694 0 : return btrfs_ioctl_encoded_read(file, argp, true);
4695 0 : case BTRFS_IOC_ENCODED_WRITE_32:
4696 0 : return btrfs_ioctl_encoded_write(file, argp, true);
4697 : #endif
4698 : }
4699 :
4700 87566 : return -ENOTTY;
4701 : }
4702 :
4703 : #ifdef CONFIG_COMPAT
4704 0 : long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
4705 : {
4706 : /*
4707 : * These all access 32-bit values anyway so no further
4708 : * handling is necessary.
4709 : */
4710 0 : switch (cmd) {
4711 0 : case FS_IOC32_GETVERSION:
4712 0 : cmd = FS_IOC_GETVERSION;
4713 0 : break;
4714 : }
4715 :
4716 0 : return btrfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
4717 : }
4718 : #endif
|
