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