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 void btrfs_double_extent_unlock(struct inode *inode1, u64 loff1, 3225 struct inode *inode2, u64 loff2, u64 len) 3226 { 3227 unlock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1); 3228 unlock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1); 3229 } 3230 3231 static void btrfs_double_extent_lock(struct inode *inode1, u64 loff1, 3232 struct inode *inode2, u64 loff2, u64 len) 3233 { 3234 if (inode1 < inode2) { 3235 swap(inode1, inode2); 3236 swap(loff1, loff2); 3237 } else if (inode1 == inode2 && loff2 < loff1) { 3238 swap(loff1, loff2); 3239 } 3240 lock_extent(&BTRFS_I(inode1)->io_tree, loff1, loff1 + len - 1); 3241 lock_extent(&BTRFS_I(inode2)->io_tree, loff2, loff2 + len - 1); 3242 } 3243 3244 static int btrfs_extent_same_range(struct inode *src, u64 loff, u64 olen, 3245 struct inode *dst, u64 dst_loff) 3246 { 3247 u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize; 3248 int ret; 3249 u64 len = olen; 3250 3251 if (loff + len == src->i_size) 3252 len = ALIGN(src->i_size, bs) - loff; 3253 /* 3254 * For same inode case we don't want our length pushed out past i_size 3255 * as comparing that data range makes no sense. 3256 * 3257 * This effectively means we require aligned extents for the single 3258 * inode case, whereas the other cases allow an unaligned length so long 3259 * as it ends at i_size. 3260 */ 3261 if (dst == src && len != olen) 3262 return -EINVAL; 3263 3264 /* 3265 * Lock destination range to serialize with concurrent readpages() and 3266 * source range to serialize with relocation. 3267 */ 3268 btrfs_double_extent_lock(src, loff, dst, dst_loff, len); 3269 ret = btrfs_clone(src, dst, loff, olen, len, dst_loff, 1); 3270 btrfs_double_extent_unlock(src, loff, dst, dst_loff, len); 3271 3272 return ret; 3273 } 3274 3275 #define BTRFS_MAX_DEDUPE_LEN SZ_16M 3276 3277 static int btrfs_extent_same(struct inode *src, u64 loff, u64 olen, 3278 struct inode *dst, u64 dst_loff) 3279 { 3280 int ret; 3281 int num_pages = PAGE_ALIGN(BTRFS_MAX_DEDUPE_LEN) >> PAGE_SHIFT; 3282 u64 i, tail_len, chunk_count; 3283 3284 /* don't make the dst file partly checksummed */ 3285 if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) != 3286 (BTRFS_I(dst)->flags & BTRFS_INODE_NODATASUM)) 3287 return -EINVAL; 3288 3289 if (IS_SWAPFILE(src) || IS_SWAPFILE(dst)) 3290 return -ETXTBSY; 3291 3292 tail_len = olen % BTRFS_MAX_DEDUPE_LEN; 3293 chunk_count = div_u64(olen, BTRFS_MAX_DEDUPE_LEN); 3294 if (chunk_count == 0) 3295 num_pages = PAGE_ALIGN(tail_len) >> PAGE_SHIFT; 3296 3297 for (i = 0; i < chunk_count; i++) { 3298 ret = btrfs_extent_same_range(src, loff, BTRFS_MAX_DEDUPE_LEN, 3299 dst, dst_loff); 3300 if (ret) 3301 return ret; 3302 3303 loff += BTRFS_MAX_DEDUPE_LEN; 3304 dst_loff += BTRFS_MAX_DEDUPE_LEN; 3305 } 3306 3307 if (tail_len > 0) 3308 ret = btrfs_extent_same_range(src, loff, tail_len, dst, 3309 dst_loff); 3310 3311 return ret; 3312 } 3313 3314 static int clone_finish_inode_update(struct btrfs_trans_handle *trans, 3315 struct inode *inode, 3316 u64 endoff, 3317 const u64 destoff, 3318 const u64 olen, 3319 int no_time_update) 3320 { 3321 struct btrfs_root *root = BTRFS_I(inode)->root; 3322 int ret; 3323 3324 inode_inc_iversion(inode); 3325 if (!no_time_update) 3326 inode->i_mtime = inode->i_ctime = current_time(inode); 3327 /* 3328 * We round up to the block size at eof when determining which 3329 * extents to clone above, but shouldn't round up the file size. 3330 */ 3331 if (endoff > destoff + olen) 3332 endoff = destoff + olen; 3333 if (endoff > inode->i_size) 3334 btrfs_i_size_write(BTRFS_I(inode), endoff); 3335 3336 ret = btrfs_update_inode(trans, root, inode); 3337 if (ret) { 3338 btrfs_abort_transaction(trans, ret); 3339 btrfs_end_transaction(trans); 3340 goto out; 3341 } 3342 ret = btrfs_end_transaction(trans); 3343 out: 3344 return ret; 3345 } 3346 3347 static void clone_update_extent_map(struct btrfs_inode *inode, 3348 const struct btrfs_trans_handle *trans, 3349 const struct btrfs_path *path, 3350 const u64 hole_offset, 3351 const u64 hole_len) 3352 { 3353 struct extent_map_tree *em_tree = &inode->extent_tree; 3354 struct extent_map *em; 3355 int ret; 3356 3357 em = alloc_extent_map(); 3358 if (!em) { 3359 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags); 3360 return; 3361 } 3362 3363 if (path) { 3364 struct btrfs_file_extent_item *fi; 3365 3366 fi = btrfs_item_ptr(path->nodes[0], path->slots[0], 3367 struct btrfs_file_extent_item); 3368 btrfs_extent_item_to_extent_map(inode, path, fi, false, em); 3369 em->generation = -1; 3370 if (btrfs_file_extent_type(path->nodes[0], fi) == 3371 BTRFS_FILE_EXTENT_INLINE) 3372 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, 3373 &inode->runtime_flags); 3374 } else { 3375 em->start = hole_offset; 3376 em->len = hole_len; 3377 em->ram_bytes = em->len; 3378 em->orig_start = hole_offset; 3379 em->block_start = EXTENT_MAP_HOLE; 3380 em->block_len = 0; 3381 em->orig_block_len = 0; 3382 em->compress_type = BTRFS_COMPRESS_NONE; 3383 em->generation = trans->transid; 3384 } 3385 3386 while (1) { 3387 write_lock(&em_tree->lock); 3388 ret = add_extent_mapping(em_tree, em, 1); 3389 write_unlock(&em_tree->lock); 3390 if (ret != -EEXIST) { 3391 free_extent_map(em); 3392 break; 3393 } 3394 btrfs_drop_extent_cache(inode, em->start, 3395 em->start + em->len - 1, 0); 3396 } 3397 3398 if (ret) 3399 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags); 3400 } 3401 3402 /* 3403 * Make sure we do not end up inserting an inline extent into a file that has 3404 * already other (non-inline) extents. If a file has an inline extent it can 3405 * not have any other extents and the (single) inline extent must start at the 3406 * file offset 0. Failing to respect these rules will lead to file corruption, 3407 * resulting in EIO errors on read/write operations, hitting BUG_ON's in mm, etc 3408 * 3409 * We can have extents that have been already written to disk or we can have 3410 * dirty ranges still in delalloc, in which case the extent maps and items are 3411 * created only when we run delalloc, and the delalloc ranges might fall outside 3412 * the range we are currently locking in the inode's io tree. So we check the 3413 * inode's i_size because of that (i_size updates are done while holding the 3414 * i_mutex, which we are holding here). 3415 * We also check to see if the inode has a size not greater than "datal" but has 3416 * extents beyond it, due to an fallocate with FALLOC_FL_KEEP_SIZE (and we are 3417 * protected against such concurrent fallocate calls by the i_mutex). 3418 * 3419 * If the file has no extents but a size greater than datal, do not allow the 3420 * copy because we would need turn the inline extent into a non-inline one (even 3421 * with NO_HOLES enabled). If we find our destination inode only has one inline 3422 * extent, just overwrite it with the source inline extent if its size is less 3423 * than the source extent's size, or we could copy the source inline extent's 3424 * data into the destination inode's inline extent if the later is greater then 3425 * the former. 3426 */ 3427 static int clone_copy_inline_extent(struct inode *dst, 3428 struct btrfs_trans_handle *trans, 3429 struct btrfs_path *path, 3430 struct btrfs_key *new_key, 3431 const u64 drop_start, 3432 const u64 datal, 3433 const u64 skip, 3434 const u64 size, 3435 char *inline_data) 3436 { 3437 struct btrfs_fs_info *fs_info = btrfs_sb(dst->i_sb); 3438 struct btrfs_root *root = BTRFS_I(dst)->root; 3439 const u64 aligned_end = ALIGN(new_key->offset + datal, 3440 fs_info->sectorsize); 3441 int ret; 3442 struct btrfs_key key; 3443 3444 if (new_key->offset > 0) 3445 return -EOPNOTSUPP; 3446 3447 key.objectid = btrfs_ino(BTRFS_I(dst)); 3448 key.type = BTRFS_EXTENT_DATA_KEY; 3449 key.offset = 0; 3450 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 3451 if (ret < 0) { 3452 return ret; 3453 } else if (ret > 0) { 3454 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { 3455 ret = btrfs_next_leaf(root, path); 3456 if (ret < 0) 3457 return ret; 3458 else if (ret > 0) 3459 goto copy_inline_extent; 3460 } 3461 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 3462 if (key.objectid == btrfs_ino(BTRFS_I(dst)) && 3463 key.type == BTRFS_EXTENT_DATA_KEY) { 3464 ASSERT(key.offset > 0); 3465 return -EOPNOTSUPP; 3466 } 3467 } else if (i_size_read(dst) <= datal) { 3468 struct btrfs_file_extent_item *ei; 3469 u64 ext_len; 3470 3471 /* 3472 * If the file size is <= datal, make sure there are no other 3473 * extents following (can happen do to an fallocate call with 3474 * the flag FALLOC_FL_KEEP_SIZE). 3475 */ 3476 ei = btrfs_item_ptr(path->nodes[0], path->slots[0], 3477 struct btrfs_file_extent_item); 3478 /* 3479 * If it's an inline extent, it can not have other extents 3480 * following it. 3481 */ 3482 if (btrfs_file_extent_type(path->nodes[0], ei) == 3483 BTRFS_FILE_EXTENT_INLINE) 3484 goto copy_inline_extent; 3485 3486 ext_len = btrfs_file_extent_num_bytes(path->nodes[0], ei); 3487 if (ext_len > aligned_end) 3488 return -EOPNOTSUPP; 3489 3490 ret = btrfs_next_item(root, path); 3491 if (ret < 0) { 3492 return ret; 3493 } else if (ret == 0) { 3494 btrfs_item_key_to_cpu(path->nodes[0], &key, 3495 path->slots[0]); 3496 if (key.objectid == btrfs_ino(BTRFS_I(dst)) && 3497 key.type == BTRFS_EXTENT_DATA_KEY) 3498 return -EOPNOTSUPP; 3499 } 3500 } 3501 3502 copy_inline_extent: 3503 /* 3504 * We have no extent items, or we have an extent at offset 0 which may 3505 * or may not be inlined. All these cases are dealt the same way. 3506 */ 3507 if (i_size_read(dst) > datal) { 3508 /* 3509 * If the destination inode has an inline extent... 3510 * This would require copying the data from the source inline 3511 * extent into the beginning of the destination's inline extent. 3512 * But this is really complex, both extents can be compressed 3513 * or just one of them, which would require decompressing and 3514 * re-compressing data (which could increase the new compressed 3515 * size, not allowing the compressed data to fit anymore in an 3516 * inline extent). 3517 * So just don't support this case for now (it should be rare, 3518 * we are not really saving space when cloning inline extents). 3519 */ 3520 return -EOPNOTSUPP; 3521 } 3522 3523 btrfs_release_path(path); 3524 ret = btrfs_drop_extents(trans, root, dst, drop_start, aligned_end, 1); 3525 if (ret) 3526 return ret; 3527 ret = btrfs_insert_empty_item(trans, root, path, new_key, size); 3528 if (ret) 3529 return ret; 3530 3531 if (skip) { 3532 const u32 start = btrfs_file_extent_calc_inline_size(0); 3533 3534 memmove(inline_data + start, inline_data + start + skip, datal); 3535 } 3536 3537 write_extent_buffer(path->nodes[0], inline_data, 3538 btrfs_item_ptr_offset(path->nodes[0], 3539 path->slots[0]), 3540 size); 3541 inode_add_bytes(dst, datal); 3542 3543 return 0; 3544 } 3545 3546 /** 3547 * btrfs_clone() - clone a range from inode file to another 3548 * 3549 * @src: Inode to clone from 3550 * @inode: Inode to clone to 3551 * @off: Offset within source to start clone from 3552 * @olen: Original length, passed by user, of range to clone 3553 * @olen_aligned: Block-aligned value of olen 3554 * @destoff: Offset within @inode to start clone 3555 * @no_time_update: Whether to update mtime/ctime on the target inode 3556 */ 3557 static int btrfs_clone(struct inode *src, struct inode *inode, 3558 const u64 off, const u64 olen, const u64 olen_aligned, 3559 const u64 destoff, int no_time_update) 3560 { 3561 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 3562 struct btrfs_root *root = BTRFS_I(inode)->root; 3563 struct btrfs_path *path = NULL; 3564 struct extent_buffer *leaf; 3565 struct btrfs_trans_handle *trans; 3566 char *buf = NULL; 3567 struct btrfs_key key; 3568 u32 nritems; 3569 int slot; 3570 int ret; 3571 const u64 len = olen_aligned; 3572 u64 last_dest_end = destoff; 3573 3574 ret = -ENOMEM; 3575 buf = kvmalloc(fs_info->nodesize, GFP_KERNEL); 3576 if (!buf) 3577 return ret; 3578 3579 path = btrfs_alloc_path(); 3580 if (!path) { 3581 kvfree(buf); 3582 return ret; 3583 } 3584 3585 path->reada = READA_FORWARD; 3586 /* clone data */ 3587 key.objectid = btrfs_ino(BTRFS_I(src)); 3588 key.type = BTRFS_EXTENT_DATA_KEY; 3589 key.offset = off; 3590 3591 while (1) { 3592 u64 next_key_min_offset = key.offset + 1; 3593 3594 /* 3595 * note the key will change type as we walk through the 3596 * tree. 3597 */ 3598 path->leave_spinning = 1; 3599 ret = btrfs_search_slot(NULL, BTRFS_I(src)->root, &key, path, 3600 0, 0); 3601 if (ret < 0) 3602 goto out; 3603 /* 3604 * First search, if no extent item that starts at offset off was 3605 * found but the previous item is an extent item, it's possible 3606 * it might overlap our target range, therefore process it. 3607 */ 3608 if (key.offset == off && ret > 0 && path->slots[0] > 0) { 3609 btrfs_item_key_to_cpu(path->nodes[0], &key, 3610 path->slots[0] - 1); 3611 if (key.type == BTRFS_EXTENT_DATA_KEY) 3612 path->slots[0]--; 3613 } 3614 3615 nritems = btrfs_header_nritems(path->nodes[0]); 3616 process_slot: 3617 if (path->slots[0] >= nritems) { 3618 ret = btrfs_next_leaf(BTRFS_I(src)->root, path); 3619 if (ret < 0) 3620 goto out; 3621 if (ret > 0) 3622 break; 3623 nritems = btrfs_header_nritems(path->nodes[0]); 3624 } 3625 leaf = path->nodes[0]; 3626 slot = path->slots[0]; 3627 3628 btrfs_item_key_to_cpu(leaf, &key, slot); 3629 if (key.type > BTRFS_EXTENT_DATA_KEY || 3630 key.objectid != btrfs_ino(BTRFS_I(src))) 3631 break; 3632 3633 if (key.type == BTRFS_EXTENT_DATA_KEY) { 3634 struct btrfs_file_extent_item *extent; 3635 int type; 3636 u32 size; 3637 struct btrfs_key new_key; 3638 u64 disko = 0, diskl = 0; 3639 u64 datao = 0, datal = 0; 3640 u8 comp; 3641 u64 drop_start; 3642 3643 extent = btrfs_item_ptr(leaf, slot, 3644 struct btrfs_file_extent_item); 3645 comp = btrfs_file_extent_compression(leaf, extent); 3646 type = btrfs_file_extent_type(leaf, extent); 3647 if (type == BTRFS_FILE_EXTENT_REG || 3648 type == BTRFS_FILE_EXTENT_PREALLOC) { 3649 disko = btrfs_file_extent_disk_bytenr(leaf, 3650 extent); 3651 diskl = btrfs_file_extent_disk_num_bytes(leaf, 3652 extent); 3653 datao = btrfs_file_extent_offset(leaf, extent); 3654 datal = btrfs_file_extent_num_bytes(leaf, 3655 extent); 3656 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 3657 /* take upper bound, may be compressed */ 3658 datal = btrfs_file_extent_ram_bytes(leaf, 3659 extent); 3660 } 3661 3662 /* 3663 * The first search might have left us at an extent 3664 * item that ends before our target range's start, can 3665 * happen if we have holes and NO_HOLES feature enabled. 3666 */ 3667 if (key.offset + datal <= off) { 3668 path->slots[0]++; 3669 goto process_slot; 3670 } else if (key.offset >= off + len) { 3671 break; 3672 } 3673 next_key_min_offset = key.offset + datal; 3674 size = btrfs_item_size_nr(leaf, slot); 3675 read_extent_buffer(leaf, buf, 3676 btrfs_item_ptr_offset(leaf, slot), 3677 size); 3678 3679 btrfs_release_path(path); 3680 path->leave_spinning = 0; 3681 3682 memcpy(&new_key, &key, sizeof(new_key)); 3683 new_key.objectid = btrfs_ino(BTRFS_I(inode)); 3684 if (off <= key.offset) 3685 new_key.offset = key.offset + destoff - off; 3686 else 3687 new_key.offset = destoff; 3688 3689 /* 3690 * Deal with a hole that doesn't have an extent item 3691 * that represents it (NO_HOLES feature enabled). 3692 * This hole is either in the middle of the cloning 3693 * range or at the beginning (fully overlaps it or 3694 * partially overlaps it). 3695 */ 3696 if (new_key.offset != last_dest_end) 3697 drop_start = last_dest_end; 3698 else 3699 drop_start = new_key.offset; 3700 3701 /* 3702 * 1 - adjusting old extent (we may have to split it) 3703 * 1 - add new extent 3704 * 1 - inode update 3705 */ 3706 trans = btrfs_start_transaction(root, 3); 3707 if (IS_ERR(trans)) { 3708 ret = PTR_ERR(trans); 3709 goto out; 3710 } 3711 3712 if (type == BTRFS_FILE_EXTENT_REG || 3713 type == BTRFS_FILE_EXTENT_PREALLOC) { 3714 /* 3715 * a | --- range to clone ---| b 3716 * | ------------- extent ------------- | 3717 */ 3718 3719 /* subtract range b */ 3720 if (key.offset + datal > off + len) 3721 datal = off + len - key.offset; 3722 3723 /* subtract range a */ 3724 if (off > key.offset) { 3725 datao += off - key.offset; 3726 datal -= off - key.offset; 3727 } 3728 3729 ret = btrfs_drop_extents(trans, root, inode, 3730 drop_start, 3731 new_key.offset + datal, 3732 1); 3733 if (ret) { 3734 if (ret != -EOPNOTSUPP) 3735 btrfs_abort_transaction(trans, 3736 ret); 3737 btrfs_end_transaction(trans); 3738 goto out; 3739 } 3740 3741 ret = btrfs_insert_empty_item(trans, root, path, 3742 &new_key, size); 3743 if (ret) { 3744 btrfs_abort_transaction(trans, ret); 3745 btrfs_end_transaction(trans); 3746 goto out; 3747 } 3748 3749 leaf = path->nodes[0]; 3750 slot = path->slots[0]; 3751 write_extent_buffer(leaf, buf, 3752 btrfs_item_ptr_offset(leaf, slot), 3753 size); 3754 3755 extent = btrfs_item_ptr(leaf, slot, 3756 struct btrfs_file_extent_item); 3757 3758 /* disko == 0 means it's a hole */ 3759 if (!disko) 3760 datao = 0; 3761 3762 btrfs_set_file_extent_offset(leaf, extent, 3763 datao); 3764 btrfs_set_file_extent_num_bytes(leaf, extent, 3765 datal); 3766 3767 if (disko) { 3768 inode_add_bytes(inode, datal); 3769 ret = btrfs_inc_extent_ref(trans, 3770 root, 3771 disko, diskl, 0, 3772 root->root_key.objectid, 3773 btrfs_ino(BTRFS_I(inode)), 3774 new_key.offset - datao); 3775 if (ret) { 3776 btrfs_abort_transaction(trans, 3777 ret); 3778 btrfs_end_transaction(trans); 3779 goto out; 3780 3781 } 3782 } 3783 } else if (type == BTRFS_FILE_EXTENT_INLINE) { 3784 u64 skip = 0; 3785 u64 trim = 0; 3786 3787 if (off > key.offset) { 3788 skip = off - key.offset; 3789 new_key.offset += skip; 3790 } 3791 3792 if (key.offset + datal > off + len) 3793 trim = key.offset + datal - (off + len); 3794 3795 if (comp && (skip || trim)) { 3796 ret = -EINVAL; 3797 btrfs_end_transaction(trans); 3798 goto out; 3799 } 3800 size -= skip + trim; 3801 datal -= skip + trim; 3802 3803 ret = clone_copy_inline_extent(inode, 3804 trans, path, 3805 &new_key, 3806 drop_start, 3807 datal, 3808 skip, size, buf); 3809 if (ret) { 3810 if (ret != -EOPNOTSUPP) 3811 btrfs_abort_transaction(trans, 3812 ret); 3813 btrfs_end_transaction(trans); 3814 goto out; 3815 } 3816 leaf = path->nodes[0]; 3817 slot = path->slots[0]; 3818 } 3819 3820 /* If we have an implicit hole (NO_HOLES feature). */ 3821 if (drop_start < new_key.offset) 3822 clone_update_extent_map(BTRFS_I(inode), trans, 3823 NULL, drop_start, 3824 new_key.offset - drop_start); 3825 3826 clone_update_extent_map(BTRFS_I(inode), trans, 3827 path, 0, 0); 3828 3829 btrfs_mark_buffer_dirty(leaf); 3830 btrfs_release_path(path); 3831 3832 last_dest_end = ALIGN(new_key.offset + datal, 3833 fs_info->sectorsize); 3834 ret = clone_finish_inode_update(trans, inode, 3835 last_dest_end, 3836 destoff, olen, 3837 no_time_update); 3838 if (ret) 3839 goto out; 3840 if (new_key.offset + datal >= destoff + len) 3841 break; 3842 } 3843 btrfs_release_path(path); 3844 key.offset = next_key_min_offset; 3845 3846 if (fatal_signal_pending(current)) { 3847 ret = -EINTR; 3848 goto out; 3849 } 3850 } 3851 ret = 0; 3852 3853 if (last_dest_end < destoff + len) { 3854 /* 3855 * We have an implicit hole (NO_HOLES feature is enabled) that 3856 * fully or partially overlaps our cloning range at its end. 3857 */ 3858 btrfs_release_path(path); 3859 3860 /* 3861 * 1 - remove extent(s) 3862 * 1 - inode update 3863 */ 3864 trans = btrfs_start_transaction(root, 2); 3865 if (IS_ERR(trans)) { 3866 ret = PTR_ERR(trans); 3867 goto out; 3868 } 3869 ret = btrfs_drop_extents(trans, root, inode, 3870 last_dest_end, destoff + len, 1); 3871 if (ret) { 3872 if (ret != -EOPNOTSUPP) 3873 btrfs_abort_transaction(trans, ret); 3874 btrfs_end_transaction(trans); 3875 goto out; 3876 } 3877 clone_update_extent_map(BTRFS_I(inode), trans, NULL, 3878 last_dest_end, 3879 destoff + len - last_dest_end); 3880 ret = clone_finish_inode_update(trans, inode, destoff + len, 3881 destoff, olen, no_time_update); 3882 } 3883 3884 out: 3885 btrfs_free_path(path); 3886 kvfree(buf); 3887 return ret; 3888 } 3889 3890 static noinline int btrfs_clone_files(struct file *file, struct file *file_src, 3891 u64 off, u64 olen, u64 destoff) 3892 { 3893 struct inode *inode = file_inode(file); 3894 struct inode *src = file_inode(file_src); 3895 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 3896 int ret; 3897 u64 len = olen; 3898 u64 bs = fs_info->sb->s_blocksize; 3899 3900 /* 3901 * TODO: 3902 * - split compressed inline extents. annoying: we need to 3903 * decompress into destination's address_space (the file offset 3904 * may change, so source mapping won't do), then recompress (or 3905 * otherwise reinsert) a subrange. 3906 * 3907 * - split destination inode's inline extents. The inline extents can 3908 * be either compressed or non-compressed. 3909 */ 3910 3911 /* don't make the dst file partly checksummed */ 3912 if ((BTRFS_I(src)->flags & BTRFS_INODE_NODATASUM) != 3913 (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) 3914 return -EINVAL; 3915 3916 if (IS_SWAPFILE(src) || IS_SWAPFILE(inode)) 3917 return -ETXTBSY; 3918 3919 /* 3920 * VFS's generic_remap_file_range_prep() protects us from cloning the 3921 * eof block into the middle of a file, which would result in corruption 3922 * if the file size is not blocksize aligned. So we don't need to check 3923 * for that case here. 3924 */ 3925 if (off + len == src->i_size) 3926 len = ALIGN(src->i_size, bs) - off; 3927 3928 if (destoff > inode->i_size) { 3929 const u64 wb_start = ALIGN_DOWN(inode->i_size, bs); 3930 3931 ret = btrfs_cont_expand(inode, inode->i_size, destoff); 3932 if (ret) 3933 return ret; 3934 /* 3935 * We may have truncated the last block if the inode's size is 3936 * not sector size aligned, so we need to wait for writeback to 3937 * complete before proceeding further, otherwise we can race 3938 * with cloning and attempt to increment a reference to an 3939 * extent that no longer exists (writeback completed right after 3940 * we found the previous extent covering eof and before we 3941 * attempted to increment its reference count). 3942 */ 3943 ret = btrfs_wait_ordered_range(inode, wb_start, 3944 destoff - wb_start); 3945 if (ret) 3946 return ret; 3947 } 3948 3949 /* 3950 * Lock destination range to serialize with concurrent readpages() and 3951 * source range to serialize with relocation. 3952 */ 3953 btrfs_double_extent_lock(src, off, inode, destoff, len); 3954 ret = btrfs_clone(src, inode, off, olen, len, destoff, 0); 3955 btrfs_double_extent_unlock(src, off, inode, destoff, len); 3956 /* 3957 * Truncate page cache pages so that future reads will see the cloned 3958 * data immediately and not the previous data. 3959 */ 3960 truncate_inode_pages_range(&inode->i_data, 3961 round_down(destoff, PAGE_SIZE), 3962 round_up(destoff + len, PAGE_SIZE) - 1); 3963 3964 return ret; 3965 } 3966 3967 static int btrfs_remap_file_range_prep(struct file *file_in, loff_t pos_in, 3968 struct file *file_out, loff_t pos_out, 3969 loff_t *len, unsigned int remap_flags) 3970 { 3971 struct inode *inode_in = file_inode(file_in); 3972 struct inode *inode_out = file_inode(file_out); 3973 u64 bs = BTRFS_I(inode_out)->root->fs_info->sb->s_blocksize; 3974 bool same_inode = inode_out == inode_in; 3975 u64 wb_len; 3976 int ret; 3977 3978 if (!(remap_flags & REMAP_FILE_DEDUP)) { 3979 struct btrfs_root *root_out = BTRFS_I(inode_out)->root; 3980 3981 if (btrfs_root_readonly(root_out)) 3982 return -EROFS; 3983 3984 if (file_in->f_path.mnt != file_out->f_path.mnt || 3985 inode_in->i_sb != inode_out->i_sb) 3986 return -EXDEV; 3987 } 3988 3989 if (same_inode) 3990 inode_lock(inode_in); 3991 else 3992 btrfs_double_inode_lock(inode_in, inode_out); 3993 3994 /* 3995 * Now that the inodes are locked, we need to start writeback ourselves 3996 * and can not rely on the writeback from the VFS's generic helper 3997 * generic_remap_file_range_prep() because: 3998 * 3999 * 1) For compression we must call filemap_fdatawrite_range() range 4000 * twice (btrfs_fdatawrite_range() does it for us), and the generic 4001 * helper only calls it once; 4002 * 4003 * 2) filemap_fdatawrite_range(), called by the generic helper only 4004 * waits for the writeback to complete, i.e. for IO to be done, and 4005 * not for the ordered extents to complete. We need to wait for them 4006 * to complete so that new file extent items are in the fs tree. 4007 */ 4008 if (*len == 0 && !(remap_flags & REMAP_FILE_DEDUP)) 4009 wb_len = ALIGN(inode_in->i_size, bs) - ALIGN_DOWN(pos_in, bs); 4010 else 4011 wb_len = ALIGN(*len, bs); 4012 4013 /* 4014 * Since we don't lock ranges, wait for ongoing lockless dio writes (as 4015 * any in progress could create its ordered extents after we wait for 4016 * existing ordered extents below). 4017 */ 4018 inode_dio_wait(inode_in); 4019 if (!same_inode) 4020 inode_dio_wait(inode_out); 4021 4022 ret = btrfs_wait_ordered_range(inode_in, ALIGN_DOWN(pos_in, bs), 4023 wb_len); 4024 if (ret < 0) 4025 goto out_unlock; 4026 ret = btrfs_wait_ordered_range(inode_out, ALIGN_DOWN(pos_out, bs), 4027 wb_len); 4028 if (ret < 0) 4029 goto out_unlock; 4030 4031 ret = generic_remap_file_range_prep(file_in, pos_in, file_out, pos_out, 4032 len, remap_flags); 4033 if (ret < 0 || *len == 0) 4034 goto out_unlock; 4035 4036 return 0; 4037 4038 out_unlock: 4039 if (same_inode) 4040 inode_unlock(inode_in); 4041 else 4042 btrfs_double_inode_unlock(inode_in, inode_out); 4043 4044 return ret; 4045 } 4046 4047 loff_t btrfs_remap_file_range(struct file *src_file, loff_t off, 4048 struct file *dst_file, loff_t destoff, loff_t len, 4049 unsigned int remap_flags) 4050 { 4051 struct inode *src_inode = file_inode(src_file); 4052 struct inode *dst_inode = file_inode(dst_file); 4053 bool same_inode = dst_inode == src_inode; 4054 int ret; 4055 4056 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY)) 4057 return -EINVAL; 4058 4059 ret = btrfs_remap_file_range_prep(src_file, off, dst_file, destoff, 4060 &len, remap_flags); 4061 if (ret < 0 || len == 0) 4062 return ret; 4063 4064 if (remap_flags & REMAP_FILE_DEDUP) 4065 ret = btrfs_extent_same(src_inode, off, len, dst_inode, destoff); 4066 else 4067 ret = btrfs_clone_files(dst_file, src_file, off, len, destoff); 4068 4069 if (same_inode) 4070 inode_unlock(src_inode); 4071 else 4072 btrfs_double_inode_unlock(src_inode, dst_inode); 4073 4074 return ret < 0 ? ret : len; 4075 } 4076 4077 static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) 4078 { 4079 struct inode *inode = file_inode(file); 4080 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 4081 struct btrfs_root *root = BTRFS_I(inode)->root; 4082 struct btrfs_root *new_root; 4083 struct btrfs_dir_item *di; 4084 struct btrfs_trans_handle *trans; 4085 struct btrfs_path *path; 4086 struct btrfs_key location; 4087 struct btrfs_disk_key disk_key; 4088 u64 objectid = 0; 4089 u64 dir_id; 4090 int ret; 4091 4092 if (!capable(CAP_SYS_ADMIN)) 4093 return -EPERM; 4094 4095 ret = mnt_want_write_file(file); 4096 if (ret) 4097 return ret; 4098 4099 if (copy_from_user(&objectid, argp, sizeof(objectid))) { 4100 ret = -EFAULT; 4101 goto out; 4102 } 4103 4104 if (!objectid) 4105 objectid = BTRFS_FS_TREE_OBJECTID; 4106 4107 location.objectid = objectid; 4108 location.type = BTRFS_ROOT_ITEM_KEY; 4109 location.offset = (u64)-1; 4110 4111 new_root = btrfs_read_fs_root_no_name(fs_info, &location); 4112 if (IS_ERR(new_root)) { 4113 ret = PTR_ERR(new_root); 4114 goto out; 4115 } 4116 if (!is_fstree(new_root->root_key.objectid)) { 4117 ret = -ENOENT; 4118 goto out; 4119 } 4120 4121 path = btrfs_alloc_path(); 4122 if (!path) { 4123 ret = -ENOMEM; 4124 goto out; 4125 } 4126 path->leave_spinning = 1; 4127 4128 trans = btrfs_start_transaction(root, 1); 4129 if (IS_ERR(trans)) { 4130 btrfs_free_path(path); 4131 ret = PTR_ERR(trans); 4132 goto out; 4133 } 4134 4135 dir_id = btrfs_super_root_dir(fs_info->super_copy); 4136 di = btrfs_lookup_dir_item(trans, fs_info->tree_root, path, 4137 dir_id, "default", 7, 1); 4138 if (IS_ERR_OR_NULL(di)) { 4139 btrfs_free_path(path); 4140 btrfs_end_transaction(trans); 4141 btrfs_err(fs_info, 4142 "Umm, you don't have the default diritem, this isn't going to work"); 4143 ret = -ENOENT; 4144 goto out; 4145 } 4146 4147 btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key); 4148 btrfs_set_dir_item_key(path->nodes[0], di, &disk_key); 4149 btrfs_mark_buffer_dirty(path->nodes[0]); 4150 btrfs_free_path(path); 4151 4152 btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL); 4153 btrfs_end_transaction(trans); 4154 out: 4155 mnt_drop_write_file(file); 4156 return ret; 4157 } 4158 4159 static void get_block_group_info(struct list_head *groups_list, 4160 struct btrfs_ioctl_space_info *space) 4161 { 4162 struct btrfs_block_group_cache *block_group; 4163 4164 space->total_bytes = 0; 4165 space->used_bytes = 0; 4166 space->flags = 0; 4167 list_for_each_entry(block_group, groups_list, list) { 4168 space->flags = block_group->flags; 4169 space->total_bytes += block_group->key.offset; 4170 space->used_bytes += 4171 btrfs_block_group_used(&block_group->item); 4172 } 4173 } 4174 4175 static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info, 4176 void __user *arg) 4177 { 4178 struct btrfs_ioctl_space_args space_args; 4179 struct btrfs_ioctl_space_info space; 4180 struct btrfs_ioctl_space_info *dest; 4181 struct btrfs_ioctl_space_info *dest_orig; 4182 struct btrfs_ioctl_space_info __user *user_dest; 4183 struct btrfs_space_info *info; 4184 static const u64 types[] = { 4185 BTRFS_BLOCK_GROUP_DATA, 4186 BTRFS_BLOCK_GROUP_SYSTEM, 4187 BTRFS_BLOCK_GROUP_METADATA, 4188 BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA 4189 }; 4190 int num_types = 4; 4191 int alloc_size; 4192 int ret = 0; 4193 u64 slot_count = 0; 4194 int i, c; 4195 4196 if (copy_from_user(&space_args, 4197 (struct btrfs_ioctl_space_args __user *)arg, 4198 sizeof(space_args))) 4199 return -EFAULT; 4200 4201 for (i = 0; i < num_types; i++) { 4202 struct btrfs_space_info *tmp; 4203 4204 info = NULL; 4205 rcu_read_lock(); 4206 list_for_each_entry_rcu(tmp, &fs_info->space_info, 4207 list) { 4208 if (tmp->flags == types[i]) { 4209 info = tmp; 4210 break; 4211 } 4212 } 4213 rcu_read_unlock(); 4214 4215 if (!info) 4216 continue; 4217 4218 down_read(&info->groups_sem); 4219 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 4220 if (!list_empty(&info->block_groups[c])) 4221 slot_count++; 4222 } 4223 up_read(&info->groups_sem); 4224 } 4225 4226 /* 4227 * Global block reserve, exported as a space_info 4228 */ 4229 slot_count++; 4230 4231 /* space_slots == 0 means they are asking for a count */ 4232 if (space_args.space_slots == 0) { 4233 space_args.total_spaces = slot_count; 4234 goto out; 4235 } 4236 4237 slot_count = min_t(u64, space_args.space_slots, slot_count); 4238 4239 alloc_size = sizeof(*dest) * slot_count; 4240 4241 /* we generally have at most 6 or so space infos, one for each raid 4242 * level. So, a whole page should be more than enough for everyone 4243 */ 4244 if (alloc_size > PAGE_SIZE) 4245 return -ENOMEM; 4246 4247 space_args.total_spaces = 0; 4248 dest = kmalloc(alloc_size, GFP_KERNEL); 4249 if (!dest) 4250 return -ENOMEM; 4251 dest_orig = dest; 4252 4253 /* now we have a buffer to copy into */ 4254 for (i = 0; i < num_types; i++) { 4255 struct btrfs_space_info *tmp; 4256 4257 if (!slot_count) 4258 break; 4259 4260 info = NULL; 4261 rcu_read_lock(); 4262 list_for_each_entry_rcu(tmp, &fs_info->space_info, 4263 list) { 4264 if (tmp->flags == types[i]) { 4265 info = tmp; 4266 break; 4267 } 4268 } 4269 rcu_read_unlock(); 4270 4271 if (!info) 4272 continue; 4273 down_read(&info->groups_sem); 4274 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) { 4275 if (!list_empty(&info->block_groups[c])) { 4276 get_block_group_info(&info->block_groups[c], 4277 &space); 4278 memcpy(dest, &space, sizeof(space)); 4279 dest++; 4280 space_args.total_spaces++; 4281 slot_count--; 4282 } 4283 if (!slot_count) 4284 break; 4285 } 4286 up_read(&info->groups_sem); 4287 } 4288 4289 /* 4290 * Add global block reserve 4291 */ 4292 if (slot_count) { 4293 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 4294 4295 spin_lock(&block_rsv->lock); 4296 space.total_bytes = block_rsv->size; 4297 space.used_bytes = block_rsv->size - block_rsv->reserved; 4298 spin_unlock(&block_rsv->lock); 4299 space.flags = BTRFS_SPACE_INFO_GLOBAL_RSV; 4300 memcpy(dest, &space, sizeof(space)); 4301 space_args.total_spaces++; 4302 } 4303 4304 user_dest = (struct btrfs_ioctl_space_info __user *) 4305 (arg + sizeof(struct btrfs_ioctl_space_args)); 4306 4307 if (copy_to_user(user_dest, dest_orig, alloc_size)) 4308 ret = -EFAULT; 4309 4310 kfree(dest_orig); 4311 out: 4312 if (ret == 0 && copy_to_user(arg, &space_args, sizeof(space_args))) 4313 ret = -EFAULT; 4314 4315 return ret; 4316 } 4317 4318 static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root, 4319 void __user *argp) 4320 { 4321 struct btrfs_trans_handle *trans; 4322 u64 transid; 4323 int ret; 4324 4325 trans = btrfs_attach_transaction_barrier(root); 4326 if (IS_ERR(trans)) { 4327 if (PTR_ERR(trans) != -ENOENT) 4328 return PTR_ERR(trans); 4329 4330 /* No running transaction, don't bother */ 4331 transid = root->fs_info->last_trans_committed; 4332 goto out; 4333 } 4334 transid = trans->transid; 4335 ret = btrfs_commit_transaction_async(trans, 0); 4336 if (ret) { 4337 btrfs_end_transaction(trans); 4338 return ret; 4339 } 4340 out: 4341 if (argp) 4342 if (copy_to_user(argp, &transid, sizeof(transid))) 4343 return -EFAULT; 4344 return 0; 4345 } 4346 4347 static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info, 4348 void __user *argp) 4349 { 4350 u64 transid; 4351 4352 if (argp) { 4353 if (copy_from_user(&transid, argp, sizeof(transid))) 4354 return -EFAULT; 4355 } else { 4356 transid = 0; /* current trans */ 4357 } 4358 return btrfs_wait_for_commit(fs_info, transid); 4359 } 4360 4361 static long btrfs_ioctl_scrub(struct file *file, void __user *arg) 4362 { 4363 struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb); 4364 struct btrfs_ioctl_scrub_args *sa; 4365 int ret; 4366 4367 if (!capable(CAP_SYS_ADMIN)) 4368 return -EPERM; 4369 4370 sa = memdup_user(arg, sizeof(*sa)); 4371 if (IS_ERR(sa)) 4372 return PTR_ERR(sa); 4373 4374 if (!(sa->flags & BTRFS_SCRUB_READONLY)) { 4375 ret = mnt_want_write_file(file); 4376 if (ret) 4377 goto out; 4378 } 4379 4380 ret = btrfs_scrub_dev(fs_info, sa->devid, sa->start, sa->end, 4381 &sa->progress, sa->flags & BTRFS_SCRUB_READONLY, 4382 0); 4383 4384 if (copy_to_user(arg, sa, sizeof(*sa))) 4385 ret = -EFAULT; 4386 4387 if (!(sa->flags & BTRFS_SCRUB_READONLY)) 4388 mnt_drop_write_file(file); 4389 out: 4390 kfree(sa); 4391 return ret; 4392 } 4393 4394 static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info) 4395 { 4396 if (!capable(CAP_SYS_ADMIN)) 4397 return -EPERM; 4398 4399 return btrfs_scrub_cancel(fs_info); 4400 } 4401 4402 static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info, 4403 void __user *arg) 4404 { 4405 struct btrfs_ioctl_scrub_args *sa; 4406 int ret; 4407 4408 if (!capable(CAP_SYS_ADMIN)) 4409 return -EPERM; 4410 4411 sa = memdup_user(arg, sizeof(*sa)); 4412 if (IS_ERR(sa)) 4413 return PTR_ERR(sa); 4414 4415 ret = btrfs_scrub_progress(fs_info, sa->devid, &sa->progress); 4416 4417 if (copy_to_user(arg, sa, sizeof(*sa))) 4418 ret = -EFAULT; 4419 4420 kfree(sa); 4421 return ret; 4422 } 4423 4424 static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info, 4425 void __user *arg) 4426 { 4427 struct btrfs_ioctl_get_dev_stats *sa; 4428 int ret; 4429 4430 sa = memdup_user(arg, sizeof(*sa)); 4431 if (IS_ERR(sa)) 4432 return PTR_ERR(sa); 4433 4434 if ((sa->flags & BTRFS_DEV_STATS_RESET) && !capable(CAP_SYS_ADMIN)) { 4435 kfree(sa); 4436 return -EPERM; 4437 } 4438 4439 ret = btrfs_get_dev_stats(fs_info, sa); 4440 4441 if (copy_to_user(arg, sa, sizeof(*sa))) 4442 ret = -EFAULT; 4443 4444 kfree(sa); 4445 return ret; 4446 } 4447 4448 static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info, 4449 void __user *arg) 4450 { 4451 struct btrfs_ioctl_dev_replace_args *p; 4452 int ret; 4453 4454 if (!capable(CAP_SYS_ADMIN)) 4455 return -EPERM; 4456 4457 p = memdup_user(arg, sizeof(*p)); 4458 if (IS_ERR(p)) 4459 return PTR_ERR(p); 4460 4461 switch (p->cmd) { 4462 case BTRFS_IOCTL_DEV_REPLACE_CMD_START: 4463 if (sb_rdonly(fs_info->sb)) { 4464 ret = -EROFS; 4465 goto out; 4466 } 4467 if (test_and_set_bit(BTRFS_FS_EXCL_OP, &fs_info->flags)) { 4468 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 4469 } else { 4470 ret = btrfs_dev_replace_by_ioctl(fs_info, p); 4471 clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags); 4472 } 4473 break; 4474 case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS: 4475 btrfs_dev_replace_status(fs_info, p); 4476 ret = 0; 4477 break; 4478 case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL: 4479 p->result = btrfs_dev_replace_cancel(fs_info); 4480 ret = 0; 4481 break; 4482 default: 4483 ret = -EINVAL; 4484 break; 4485 } 4486 4487 if (copy_to_user(arg, p, sizeof(*p))) 4488 ret = -EFAULT; 4489 out: 4490 kfree(p); 4491 return ret; 4492 } 4493 4494 static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg) 4495 { 4496 int ret = 0; 4497 int i; 4498 u64 rel_ptr; 4499 int size; 4500 struct btrfs_ioctl_ino_path_args *ipa = NULL; 4501 struct inode_fs_paths *ipath = NULL; 4502 struct btrfs_path *path; 4503 4504 if (!capable(CAP_DAC_READ_SEARCH)) 4505 return -EPERM; 4506 4507 path = btrfs_alloc_path(); 4508 if (!path) { 4509 ret = -ENOMEM; 4510 goto out; 4511 } 4512 4513 ipa = memdup_user(arg, sizeof(*ipa)); 4514 if (IS_ERR(ipa)) { 4515 ret = PTR_ERR(ipa); 4516 ipa = NULL; 4517 goto out; 4518 } 4519 4520 size = min_t(u32, ipa->size, 4096); 4521 ipath = init_ipath(size, root, path); 4522 if (IS_ERR(ipath)) { 4523 ret = PTR_ERR(ipath); 4524 ipath = NULL; 4525 goto out; 4526 } 4527 4528 ret = paths_from_inode(ipa->inum, ipath); 4529 if (ret < 0) 4530 goto out; 4531 4532 for (i = 0; i < ipath->fspath->elem_cnt; ++i) { 4533 rel_ptr = ipath->fspath->val[i] - 4534 (u64)(unsigned long)ipath->fspath->val; 4535 ipath->fspath->val[i] = rel_ptr; 4536 } 4537 4538 ret = copy_to_user((void __user *)(unsigned long)ipa->fspath, 4539 ipath->fspath, size); 4540 if (ret) { 4541 ret = -EFAULT; 4542 goto out; 4543 } 4544 4545 out: 4546 btrfs_free_path(path); 4547 free_ipath(ipath); 4548 kfree(ipa); 4549 4550 return ret; 4551 } 4552 4553 static int build_ino_list(u64 inum, u64 offset, u64 root, void *ctx) 4554 { 4555 struct btrfs_data_container *inodes = ctx; 4556 const size_t c = 3 * sizeof(u64); 4557 4558 if (inodes->bytes_left >= c) { 4559 inodes->bytes_left -= c; 4560 inodes->val[inodes->elem_cnt] = inum; 4561 inodes->val[inodes->elem_cnt + 1] = offset; 4562 inodes->val[inodes->elem_cnt + 2] = root; 4563 inodes->elem_cnt += 3; 4564 } else { 4565 inodes->bytes_missing += c - inodes->bytes_left; 4566 inodes->bytes_left = 0; 4567 inodes->elem_missed += 3; 4568 } 4569 4570 return 0; 4571 } 4572 4573 static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info, 4574 void __user *arg, int version) 4575 { 4576 int ret = 0; 4577 int size; 4578 struct btrfs_ioctl_logical_ino_args *loi; 4579 struct btrfs_data_container *inodes = NULL; 4580 struct btrfs_path *path = NULL; 4581 bool ignore_offset; 4582 4583 if (!capable(CAP_SYS_ADMIN)) 4584 return -EPERM; 4585 4586 loi = memdup_user(arg, sizeof(*loi)); 4587 if (IS_ERR(loi)) 4588 return PTR_ERR(loi); 4589 4590 if (version == 1) { 4591 ignore_offset = false; 4592 size = min_t(u32, loi->size, SZ_64K); 4593 } else { 4594 /* All reserved bits must be 0 for now */ 4595 if (memchr_inv(loi->reserved, 0, sizeof(loi->reserved))) { 4596 ret = -EINVAL; 4597 goto out_loi; 4598 } 4599 /* Only accept flags we have defined so far */ 4600 if (loi->flags & ~(BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET)) { 4601 ret = -EINVAL; 4602 goto out_loi; 4603 } 4604 ignore_offset = loi->flags & BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET; 4605 size = min_t(u32, loi->size, SZ_16M); 4606 } 4607 4608 path = btrfs_alloc_path(); 4609 if (!path) { 4610 ret = -ENOMEM; 4611 goto out; 4612 } 4613 4614 inodes = init_data_container(size); 4615 if (IS_ERR(inodes)) { 4616 ret = PTR_ERR(inodes); 4617 inodes = NULL; 4618 goto out; 4619 } 4620 4621 ret = iterate_inodes_from_logical(loi->logical, fs_info, path, 4622 build_ino_list, inodes, ignore_offset); 4623 if (ret == -EINVAL) 4624 ret = -ENOENT; 4625 if (ret < 0) 4626 goto out; 4627 4628 ret = copy_to_user((void __user *)(unsigned long)loi->inodes, inodes, 4629 size); 4630 if (ret) 4631 ret = -EFAULT; 4632 4633 out: 4634 btrfs_free_path(path); 4635 kvfree(inodes); 4636 out_loi: 4637 kfree(loi); 4638 4639 return ret; 4640 } 4641 4642 void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info, 4643 struct btrfs_ioctl_balance_args *bargs) 4644 { 4645 struct btrfs_balance_control *bctl = fs_info->balance_ctl; 4646 4647 bargs->flags = bctl->flags; 4648 4649 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) 4650 bargs->state |= BTRFS_BALANCE_STATE_RUNNING; 4651 if (atomic_read(&fs_info->balance_pause_req)) 4652 bargs->state |= BTRFS_BALANCE_STATE_PAUSE_REQ; 4653 if (atomic_read(&fs_info->balance_cancel_req)) 4654 bargs->state |= BTRFS_BALANCE_STATE_CANCEL_REQ; 4655 4656 memcpy(&bargs->data, &bctl->data, sizeof(bargs->data)); 4657 memcpy(&bargs->meta, &bctl->meta, sizeof(bargs->meta)); 4658 memcpy(&bargs->sys, &bctl->sys, sizeof(bargs->sys)); 4659 4660 spin_lock(&fs_info->balance_lock); 4661 memcpy(&bargs->stat, &bctl->stat, sizeof(bargs->stat)); 4662 spin_unlock(&fs_info->balance_lock); 4663 } 4664 4665 static long btrfs_ioctl_balance(struct file *file, void __user *arg) 4666 { 4667 struct btrfs_root *root = BTRFS_I(file_inode(file))->root; 4668 struct btrfs_fs_info *fs_info = root->fs_info; 4669 struct btrfs_ioctl_balance_args *bargs; 4670 struct btrfs_balance_control *bctl; 4671 bool need_unlock; /* for mut. excl. ops lock */ 4672 int ret; 4673 4674 if (!capable(CAP_SYS_ADMIN)) 4675 return -EPERM; 4676 4677 ret = mnt_want_write_file(file); 4678 if (ret) 4679 return ret; 4680 4681 again: 4682 if (!test_and_set_bit(BTRFS_FS_EXCL_OP, &fs_info->flags)) { 4683 mutex_lock(&fs_info->balance_mutex); 4684 need_unlock = true; 4685 goto locked; 4686 } 4687 4688 /* 4689 * mut. excl. ops lock is locked. Three possibilities: 4690 * (1) some other op is running 4691 * (2) balance is running 4692 * (3) balance is paused -- special case (think resume) 4693 */ 4694 mutex_lock(&fs_info->balance_mutex); 4695 if (fs_info->balance_ctl) { 4696 /* this is either (2) or (3) */ 4697 if (!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { 4698 mutex_unlock(&fs_info->balance_mutex); 4699 /* 4700 * Lock released to allow other waiters to continue, 4701 * we'll reexamine the status again. 4702 */ 4703 mutex_lock(&fs_info->balance_mutex); 4704 4705 if (fs_info->balance_ctl && 4706 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { 4707 /* this is (3) */ 4708 need_unlock = false; 4709 goto locked; 4710 } 4711 4712 mutex_unlock(&fs_info->balance_mutex); 4713 goto again; 4714 } else { 4715 /* this is (2) */ 4716 mutex_unlock(&fs_info->balance_mutex); 4717 ret = -EINPROGRESS; 4718 goto out; 4719 } 4720 } else { 4721 /* this is (1) */ 4722 mutex_unlock(&fs_info->balance_mutex); 4723 ret = BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS; 4724 goto out; 4725 } 4726 4727 locked: 4728 BUG_ON(!test_bit(BTRFS_FS_EXCL_OP, &fs_info->flags)); 4729 4730 if (arg) { 4731 bargs = memdup_user(arg, sizeof(*bargs)); 4732 if (IS_ERR(bargs)) { 4733 ret = PTR_ERR(bargs); 4734 goto out_unlock; 4735 } 4736 4737 if (bargs->flags & BTRFS_BALANCE_RESUME) { 4738 if (!fs_info->balance_ctl) { 4739 ret = -ENOTCONN; 4740 goto out_bargs; 4741 } 4742 4743 bctl = fs_info->balance_ctl; 4744 spin_lock(&fs_info->balance_lock); 4745 bctl->flags |= BTRFS_BALANCE_RESUME; 4746 spin_unlock(&fs_info->balance_lock); 4747 4748 goto do_balance; 4749 } 4750 } else { 4751 bargs = NULL; 4752 } 4753 4754 if (fs_info->balance_ctl) { 4755 ret = -EINPROGRESS; 4756 goto out_bargs; 4757 } 4758 4759 bctl = kzalloc(sizeof(*bctl), GFP_KERNEL); 4760 if (!bctl) { 4761 ret = -ENOMEM; 4762 goto out_bargs; 4763 } 4764 4765 if (arg) { 4766 memcpy(&bctl->data, &bargs->data, sizeof(bctl->data)); 4767 memcpy(&bctl->meta, &bargs->meta, sizeof(bctl->meta)); 4768 memcpy(&bctl->sys, &bargs->sys, sizeof(bctl->sys)); 4769 4770 bctl->flags = bargs->flags; 4771 } else { 4772 /* balance everything - no filters */ 4773 bctl->flags |= BTRFS_BALANCE_TYPE_MASK; 4774 } 4775 4776 if (bctl->flags & ~(BTRFS_BALANCE_ARGS_MASK | BTRFS_BALANCE_TYPE_MASK)) { 4777 ret = -EINVAL; 4778 goto out_bctl; 4779 } 4780 4781 do_balance: 4782 /* 4783 * Ownership of bctl and filesystem flag BTRFS_FS_EXCL_OP goes to 4784 * btrfs_balance. bctl is freed in reset_balance_state, or, if 4785 * restriper was paused all the way until unmount, in free_fs_info. 4786 * The flag should be cleared after reset_balance_state. 4787 */ 4788 need_unlock = false; 4789 4790 ret = btrfs_balance(fs_info, bctl, bargs); 4791 bctl = NULL; 4792 4793 if (arg) { 4794 if (copy_to_user(arg, bargs, sizeof(*bargs))) 4795 ret = -EFAULT; 4796 } 4797 4798 out_bctl: 4799 kfree(bctl); 4800 out_bargs: 4801 kfree(bargs); 4802 out_unlock: 4803 mutex_unlock(&fs_info->balance_mutex); 4804 if (need_unlock) 4805 clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags); 4806 out: 4807 mnt_drop_write_file(file); 4808 return ret; 4809 } 4810 4811 static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd) 4812 { 4813 if (!capable(CAP_SYS_ADMIN)) 4814 return -EPERM; 4815 4816 switch (cmd) { 4817 case BTRFS_BALANCE_CTL_PAUSE: 4818 return btrfs_pause_balance(fs_info); 4819 case BTRFS_BALANCE_CTL_CANCEL: 4820 return btrfs_cancel_balance(fs_info); 4821 } 4822 4823 return -EINVAL; 4824 } 4825 4826 static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info, 4827 void __user *arg) 4828 { 4829 struct btrfs_ioctl_balance_args *bargs; 4830 int ret = 0; 4831 4832 if (!capable(CAP_SYS_ADMIN)) 4833 return -EPERM; 4834 4835 mutex_lock(&fs_info->balance_mutex); 4836 if (!fs_info->balance_ctl) { 4837 ret = -ENOTCONN; 4838 goto out; 4839 } 4840 4841 bargs = kzalloc(sizeof(*bargs), GFP_KERNEL); 4842 if (!bargs) { 4843 ret = -ENOMEM; 4844 goto out; 4845 } 4846 4847 btrfs_update_ioctl_balance_args(fs_info, bargs); 4848 4849 if (copy_to_user(arg, bargs, sizeof(*bargs))) 4850 ret = -EFAULT; 4851 4852 kfree(bargs); 4853 out: 4854 mutex_unlock(&fs_info->balance_mutex); 4855 return ret; 4856 } 4857 4858 static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg) 4859 { 4860 struct inode *inode = file_inode(file); 4861 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 4862 struct btrfs_ioctl_quota_ctl_args *sa; 4863 int ret; 4864 4865 if (!capable(CAP_SYS_ADMIN)) 4866 return -EPERM; 4867 4868 ret = mnt_want_write_file(file); 4869 if (ret) 4870 return ret; 4871 4872 sa = memdup_user(arg, sizeof(*sa)); 4873 if (IS_ERR(sa)) { 4874 ret = PTR_ERR(sa); 4875 goto drop_write; 4876 } 4877 4878 down_write(&fs_info->subvol_sem); 4879 4880 switch (sa->cmd) { 4881 case BTRFS_QUOTA_CTL_ENABLE: 4882 ret = btrfs_quota_enable(fs_info); 4883 break; 4884 case BTRFS_QUOTA_CTL_DISABLE: 4885 ret = btrfs_quota_disable(fs_info); 4886 break; 4887 default: 4888 ret = -EINVAL; 4889 break; 4890 } 4891 4892 kfree(sa); 4893 up_write(&fs_info->subvol_sem); 4894 drop_write: 4895 mnt_drop_write_file(file); 4896 return ret; 4897 } 4898 4899 static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg) 4900 { 4901 struct inode *inode = file_inode(file); 4902 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 4903 struct btrfs_root *root = BTRFS_I(inode)->root; 4904 struct btrfs_ioctl_qgroup_assign_args *sa; 4905 struct btrfs_trans_handle *trans; 4906 int ret; 4907 int err; 4908 4909 if (!capable(CAP_SYS_ADMIN)) 4910 return -EPERM; 4911 4912 ret = mnt_want_write_file(file); 4913 if (ret) 4914 return ret; 4915 4916 sa = memdup_user(arg, sizeof(*sa)); 4917 if (IS_ERR(sa)) { 4918 ret = PTR_ERR(sa); 4919 goto drop_write; 4920 } 4921 4922 trans = btrfs_join_transaction(root); 4923 if (IS_ERR(trans)) { 4924 ret = PTR_ERR(trans); 4925 goto out; 4926 } 4927 4928 if (sa->assign) { 4929 ret = btrfs_add_qgroup_relation(trans, sa->src, sa->dst); 4930 } else { 4931 ret = btrfs_del_qgroup_relation(trans, sa->src, sa->dst); 4932 } 4933 4934 /* update qgroup status and info */ 4935 err = btrfs_run_qgroups(trans); 4936 if (err < 0) 4937 btrfs_handle_fs_error(fs_info, err, 4938 "failed to update qgroup status and info"); 4939 err = btrfs_end_transaction(trans); 4940 if (err && !ret) 4941 ret = err; 4942 4943 out: 4944 kfree(sa); 4945 drop_write: 4946 mnt_drop_write_file(file); 4947 return ret; 4948 } 4949 4950 static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg) 4951 { 4952 struct inode *inode = file_inode(file); 4953 struct btrfs_root *root = BTRFS_I(inode)->root; 4954 struct btrfs_ioctl_qgroup_create_args *sa; 4955 struct btrfs_trans_handle *trans; 4956 int ret; 4957 int err; 4958 4959 if (!capable(CAP_SYS_ADMIN)) 4960 return -EPERM; 4961 4962 ret = mnt_want_write_file(file); 4963 if (ret) 4964 return ret; 4965 4966 sa = memdup_user(arg, sizeof(*sa)); 4967 if (IS_ERR(sa)) { 4968 ret = PTR_ERR(sa); 4969 goto drop_write; 4970 } 4971 4972 if (!sa->qgroupid) { 4973 ret = -EINVAL; 4974 goto out; 4975 } 4976 4977 trans = btrfs_join_transaction(root); 4978 if (IS_ERR(trans)) { 4979 ret = PTR_ERR(trans); 4980 goto out; 4981 } 4982 4983 if (sa->create) { 4984 ret = btrfs_create_qgroup(trans, sa->qgroupid); 4985 } else { 4986 ret = btrfs_remove_qgroup(trans, sa->qgroupid); 4987 } 4988 4989 err = btrfs_end_transaction(trans); 4990 if (err && !ret) 4991 ret = err; 4992 4993 out: 4994 kfree(sa); 4995 drop_write: 4996 mnt_drop_write_file(file); 4997 return ret; 4998 } 4999 5000 static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg) 5001 { 5002 struct inode *inode = file_inode(file); 5003 struct btrfs_root *root = BTRFS_I(inode)->root; 5004 struct btrfs_ioctl_qgroup_limit_args *sa; 5005 struct btrfs_trans_handle *trans; 5006 int ret; 5007 int err; 5008 u64 qgroupid; 5009 5010 if (!capable(CAP_SYS_ADMIN)) 5011 return -EPERM; 5012 5013 ret = mnt_want_write_file(file); 5014 if (ret) 5015 return ret; 5016 5017 sa = memdup_user(arg, sizeof(*sa)); 5018 if (IS_ERR(sa)) { 5019 ret = PTR_ERR(sa); 5020 goto drop_write; 5021 } 5022 5023 trans = btrfs_join_transaction(root); 5024 if (IS_ERR(trans)) { 5025 ret = PTR_ERR(trans); 5026 goto out; 5027 } 5028 5029 qgroupid = sa->qgroupid; 5030 if (!qgroupid) { 5031 /* take the current subvol as qgroup */ 5032 qgroupid = root->root_key.objectid; 5033 } 5034 5035 ret = btrfs_limit_qgroup(trans, qgroupid, &sa->lim); 5036 5037 err = btrfs_end_transaction(trans); 5038 if (err && !ret) 5039 ret = err; 5040 5041 out: 5042 kfree(sa); 5043 drop_write: 5044 mnt_drop_write_file(file); 5045 return ret; 5046 } 5047 5048 static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg) 5049 { 5050 struct inode *inode = file_inode(file); 5051 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5052 struct btrfs_ioctl_quota_rescan_args *qsa; 5053 int ret; 5054 5055 if (!capable(CAP_SYS_ADMIN)) 5056 return -EPERM; 5057 5058 ret = mnt_want_write_file(file); 5059 if (ret) 5060 return ret; 5061 5062 qsa = memdup_user(arg, sizeof(*qsa)); 5063 if (IS_ERR(qsa)) { 5064 ret = PTR_ERR(qsa); 5065 goto drop_write; 5066 } 5067 5068 if (qsa->flags) { 5069 ret = -EINVAL; 5070 goto out; 5071 } 5072 5073 ret = btrfs_qgroup_rescan(fs_info); 5074 5075 out: 5076 kfree(qsa); 5077 drop_write: 5078 mnt_drop_write_file(file); 5079 return ret; 5080 } 5081 5082 static long btrfs_ioctl_quota_rescan_status(struct file *file, void __user *arg) 5083 { 5084 struct inode *inode = file_inode(file); 5085 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5086 struct btrfs_ioctl_quota_rescan_args *qsa; 5087 int ret = 0; 5088 5089 if (!capable(CAP_SYS_ADMIN)) 5090 return -EPERM; 5091 5092 qsa = kzalloc(sizeof(*qsa), GFP_KERNEL); 5093 if (!qsa) 5094 return -ENOMEM; 5095 5096 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 5097 qsa->flags = 1; 5098 qsa->progress = fs_info->qgroup_rescan_progress.objectid; 5099 } 5100 5101 if (copy_to_user(arg, qsa, sizeof(*qsa))) 5102 ret = -EFAULT; 5103 5104 kfree(qsa); 5105 return ret; 5106 } 5107 5108 static long btrfs_ioctl_quota_rescan_wait(struct file *file, void __user *arg) 5109 { 5110 struct inode *inode = file_inode(file); 5111 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5112 5113 if (!capable(CAP_SYS_ADMIN)) 5114 return -EPERM; 5115 5116 return btrfs_qgroup_wait_for_completion(fs_info, true); 5117 } 5118 5119 static long _btrfs_ioctl_set_received_subvol(struct file *file, 5120 struct btrfs_ioctl_received_subvol_args *sa) 5121 { 5122 struct inode *inode = file_inode(file); 5123 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5124 struct btrfs_root *root = BTRFS_I(inode)->root; 5125 struct btrfs_root_item *root_item = &root->root_item; 5126 struct btrfs_trans_handle *trans; 5127 struct timespec64 ct = current_time(inode); 5128 int ret = 0; 5129 int received_uuid_changed; 5130 5131 if (!inode_owner_or_capable(inode)) 5132 return -EPERM; 5133 5134 ret = mnt_want_write_file(file); 5135 if (ret < 0) 5136 return ret; 5137 5138 down_write(&fs_info->subvol_sem); 5139 5140 if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) { 5141 ret = -EINVAL; 5142 goto out; 5143 } 5144 5145 if (btrfs_root_readonly(root)) { 5146 ret = -EROFS; 5147 goto out; 5148 } 5149 5150 /* 5151 * 1 - root item 5152 * 2 - uuid items (received uuid + subvol uuid) 5153 */ 5154 trans = btrfs_start_transaction(root, 3); 5155 if (IS_ERR(trans)) { 5156 ret = PTR_ERR(trans); 5157 trans = NULL; 5158 goto out; 5159 } 5160 5161 sa->rtransid = trans->transid; 5162 sa->rtime.sec = ct.tv_sec; 5163 sa->rtime.nsec = ct.tv_nsec; 5164 5165 received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid, 5166 BTRFS_UUID_SIZE); 5167 if (received_uuid_changed && 5168 !btrfs_is_empty_uuid(root_item->received_uuid)) { 5169 ret = btrfs_uuid_tree_remove(trans, root_item->received_uuid, 5170 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 5171 root->root_key.objectid); 5172 if (ret && ret != -ENOENT) { 5173 btrfs_abort_transaction(trans, ret); 5174 btrfs_end_transaction(trans); 5175 goto out; 5176 } 5177 } 5178 memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE); 5179 btrfs_set_root_stransid(root_item, sa->stransid); 5180 btrfs_set_root_rtransid(root_item, sa->rtransid); 5181 btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec); 5182 btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec); 5183 btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec); 5184 btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec); 5185 5186 ret = btrfs_update_root(trans, fs_info->tree_root, 5187 &root->root_key, &root->root_item); 5188 if (ret < 0) { 5189 btrfs_end_transaction(trans); 5190 goto out; 5191 } 5192 if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) { 5193 ret = btrfs_uuid_tree_add(trans, sa->uuid, 5194 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 5195 root->root_key.objectid); 5196 if (ret < 0 && ret != -EEXIST) { 5197 btrfs_abort_transaction(trans, ret); 5198 btrfs_end_transaction(trans); 5199 goto out; 5200 } 5201 } 5202 ret = btrfs_commit_transaction(trans); 5203 out: 5204 up_write(&fs_info->subvol_sem); 5205 mnt_drop_write_file(file); 5206 return ret; 5207 } 5208 5209 #ifdef CONFIG_64BIT 5210 static long btrfs_ioctl_set_received_subvol_32(struct file *file, 5211 void __user *arg) 5212 { 5213 struct btrfs_ioctl_received_subvol_args_32 *args32 = NULL; 5214 struct btrfs_ioctl_received_subvol_args *args64 = NULL; 5215 int ret = 0; 5216 5217 args32 = memdup_user(arg, sizeof(*args32)); 5218 if (IS_ERR(args32)) 5219 return PTR_ERR(args32); 5220 5221 args64 = kmalloc(sizeof(*args64), GFP_KERNEL); 5222 if (!args64) { 5223 ret = -ENOMEM; 5224 goto out; 5225 } 5226 5227 memcpy(args64->uuid, args32->uuid, BTRFS_UUID_SIZE); 5228 args64->stransid = args32->stransid; 5229 args64->rtransid = args32->rtransid; 5230 args64->stime.sec = args32->stime.sec; 5231 args64->stime.nsec = args32->stime.nsec; 5232 args64->rtime.sec = args32->rtime.sec; 5233 args64->rtime.nsec = args32->rtime.nsec; 5234 args64->flags = args32->flags; 5235 5236 ret = _btrfs_ioctl_set_received_subvol(file, args64); 5237 if (ret) 5238 goto out; 5239 5240 memcpy(args32->uuid, args64->uuid, BTRFS_UUID_SIZE); 5241 args32->stransid = args64->stransid; 5242 args32->rtransid = args64->rtransid; 5243 args32->stime.sec = args64->stime.sec; 5244 args32->stime.nsec = args64->stime.nsec; 5245 args32->rtime.sec = args64->rtime.sec; 5246 args32->rtime.nsec = args64->rtime.nsec; 5247 args32->flags = args64->flags; 5248 5249 ret = copy_to_user(arg, args32, sizeof(*args32)); 5250 if (ret) 5251 ret = -EFAULT; 5252 5253 out: 5254 kfree(args32); 5255 kfree(args64); 5256 return ret; 5257 } 5258 #endif 5259 5260 static long btrfs_ioctl_set_received_subvol(struct file *file, 5261 void __user *arg) 5262 { 5263 struct btrfs_ioctl_received_subvol_args *sa = NULL; 5264 int ret = 0; 5265 5266 sa = memdup_user(arg, sizeof(*sa)); 5267 if (IS_ERR(sa)) 5268 return PTR_ERR(sa); 5269 5270 ret = _btrfs_ioctl_set_received_subvol(file, sa); 5271 5272 if (ret) 5273 goto out; 5274 5275 ret = copy_to_user(arg, sa, sizeof(*sa)); 5276 if (ret) 5277 ret = -EFAULT; 5278 5279 out: 5280 kfree(sa); 5281 return ret; 5282 } 5283 5284 static int btrfs_ioctl_get_fslabel(struct file *file, void __user *arg) 5285 { 5286 struct inode *inode = file_inode(file); 5287 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5288 size_t len; 5289 int ret; 5290 char label[BTRFS_LABEL_SIZE]; 5291 5292 spin_lock(&fs_info->super_lock); 5293 memcpy(label, fs_info->super_copy->label, BTRFS_LABEL_SIZE); 5294 spin_unlock(&fs_info->super_lock); 5295 5296 len = strnlen(label, BTRFS_LABEL_SIZE); 5297 5298 if (len == BTRFS_LABEL_SIZE) { 5299 btrfs_warn(fs_info, 5300 "label is too long, return the first %zu bytes", 5301 --len); 5302 } 5303 5304 ret = copy_to_user(arg, label, len); 5305 5306 return ret ? -EFAULT : 0; 5307 } 5308 5309 static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg) 5310 { 5311 struct inode *inode = file_inode(file); 5312 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5313 struct btrfs_root *root = BTRFS_I(inode)->root; 5314 struct btrfs_super_block *super_block = fs_info->super_copy; 5315 struct btrfs_trans_handle *trans; 5316 char label[BTRFS_LABEL_SIZE]; 5317 int ret; 5318 5319 if (!capable(CAP_SYS_ADMIN)) 5320 return -EPERM; 5321 5322 if (copy_from_user(label, arg, sizeof(label))) 5323 return -EFAULT; 5324 5325 if (strnlen(label, BTRFS_LABEL_SIZE) == BTRFS_LABEL_SIZE) { 5326 btrfs_err(fs_info, 5327 "unable to set label with more than %d bytes", 5328 BTRFS_LABEL_SIZE - 1); 5329 return -EINVAL; 5330 } 5331 5332 ret = mnt_want_write_file(file); 5333 if (ret) 5334 return ret; 5335 5336 trans = btrfs_start_transaction(root, 0); 5337 if (IS_ERR(trans)) { 5338 ret = PTR_ERR(trans); 5339 goto out_unlock; 5340 } 5341 5342 spin_lock(&fs_info->super_lock); 5343 strcpy(super_block->label, label); 5344 spin_unlock(&fs_info->super_lock); 5345 ret = btrfs_commit_transaction(trans); 5346 5347 out_unlock: 5348 mnt_drop_write_file(file); 5349 return ret; 5350 } 5351 5352 #define INIT_FEATURE_FLAGS(suffix) \ 5353 { .compat_flags = BTRFS_FEATURE_COMPAT_##suffix, \ 5354 .compat_ro_flags = BTRFS_FEATURE_COMPAT_RO_##suffix, \ 5355 .incompat_flags = BTRFS_FEATURE_INCOMPAT_##suffix } 5356 5357 int btrfs_ioctl_get_supported_features(void __user *arg) 5358 { 5359 static const struct btrfs_ioctl_feature_flags features[3] = { 5360 INIT_FEATURE_FLAGS(SUPP), 5361 INIT_FEATURE_FLAGS(SAFE_SET), 5362 INIT_FEATURE_FLAGS(SAFE_CLEAR) 5363 }; 5364 5365 if (copy_to_user(arg, &features, sizeof(features))) 5366 return -EFAULT; 5367 5368 return 0; 5369 } 5370 5371 static int btrfs_ioctl_get_features(struct file *file, void __user *arg) 5372 { 5373 struct inode *inode = file_inode(file); 5374 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5375 struct btrfs_super_block *super_block = fs_info->super_copy; 5376 struct btrfs_ioctl_feature_flags features; 5377 5378 features.compat_flags = btrfs_super_compat_flags(super_block); 5379 features.compat_ro_flags = btrfs_super_compat_ro_flags(super_block); 5380 features.incompat_flags = btrfs_super_incompat_flags(super_block); 5381 5382 if (copy_to_user(arg, &features, sizeof(features))) 5383 return -EFAULT; 5384 5385 return 0; 5386 } 5387 5388 static int check_feature_bits(struct btrfs_fs_info *fs_info, 5389 enum btrfs_feature_set set, 5390 u64 change_mask, u64 flags, u64 supported_flags, 5391 u64 safe_set, u64 safe_clear) 5392 { 5393 const char *type = btrfs_feature_set_names[set]; 5394 char *names; 5395 u64 disallowed, unsupported; 5396 u64 set_mask = flags & change_mask; 5397 u64 clear_mask = ~flags & change_mask; 5398 5399 unsupported = set_mask & ~supported_flags; 5400 if (unsupported) { 5401 names = btrfs_printable_features(set, unsupported); 5402 if (names) { 5403 btrfs_warn(fs_info, 5404 "this kernel does not support the %s feature bit%s", 5405 names, strchr(names, ',') ? "s" : ""); 5406 kfree(names); 5407 } else 5408 btrfs_warn(fs_info, 5409 "this kernel does not support %s bits 0x%llx", 5410 type, unsupported); 5411 return -EOPNOTSUPP; 5412 } 5413 5414 disallowed = set_mask & ~safe_set; 5415 if (disallowed) { 5416 names = btrfs_printable_features(set, disallowed); 5417 if (names) { 5418 btrfs_warn(fs_info, 5419 "can't set the %s feature bit%s while mounted", 5420 names, strchr(names, ',') ? "s" : ""); 5421 kfree(names); 5422 } else 5423 btrfs_warn(fs_info, 5424 "can't set %s bits 0x%llx while mounted", 5425 type, disallowed); 5426 return -EPERM; 5427 } 5428 5429 disallowed = clear_mask & ~safe_clear; 5430 if (disallowed) { 5431 names = btrfs_printable_features(set, disallowed); 5432 if (names) { 5433 btrfs_warn(fs_info, 5434 "can't clear the %s feature bit%s while mounted", 5435 names, strchr(names, ',') ? "s" : ""); 5436 kfree(names); 5437 } else 5438 btrfs_warn(fs_info, 5439 "can't clear %s bits 0x%llx while mounted", 5440 type, disallowed); 5441 return -EPERM; 5442 } 5443 5444 return 0; 5445 } 5446 5447 #define check_feature(fs_info, change_mask, flags, mask_base) \ 5448 check_feature_bits(fs_info, FEAT_##mask_base, change_mask, flags, \ 5449 BTRFS_FEATURE_ ## mask_base ## _SUPP, \ 5450 BTRFS_FEATURE_ ## mask_base ## _SAFE_SET, \ 5451 BTRFS_FEATURE_ ## mask_base ## _SAFE_CLEAR) 5452 5453 static int btrfs_ioctl_set_features(struct file *file, void __user *arg) 5454 { 5455 struct inode *inode = file_inode(file); 5456 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5457 struct btrfs_root *root = BTRFS_I(inode)->root; 5458 struct btrfs_super_block *super_block = fs_info->super_copy; 5459 struct btrfs_ioctl_feature_flags flags[2]; 5460 struct btrfs_trans_handle *trans; 5461 u64 newflags; 5462 int ret; 5463 5464 if (!capable(CAP_SYS_ADMIN)) 5465 return -EPERM; 5466 5467 if (copy_from_user(flags, arg, sizeof(flags))) 5468 return -EFAULT; 5469 5470 /* Nothing to do */ 5471 if (!flags[0].compat_flags && !flags[0].compat_ro_flags && 5472 !flags[0].incompat_flags) 5473 return 0; 5474 5475 ret = check_feature(fs_info, flags[0].compat_flags, 5476 flags[1].compat_flags, COMPAT); 5477 if (ret) 5478 return ret; 5479 5480 ret = check_feature(fs_info, flags[0].compat_ro_flags, 5481 flags[1].compat_ro_flags, COMPAT_RO); 5482 if (ret) 5483 return ret; 5484 5485 ret = check_feature(fs_info, flags[0].incompat_flags, 5486 flags[1].incompat_flags, INCOMPAT); 5487 if (ret) 5488 return ret; 5489 5490 ret = mnt_want_write_file(file); 5491 if (ret) 5492 return ret; 5493 5494 trans = btrfs_start_transaction(root, 0); 5495 if (IS_ERR(trans)) { 5496 ret = PTR_ERR(trans); 5497 goto out_drop_write; 5498 } 5499 5500 spin_lock(&fs_info->super_lock); 5501 newflags = btrfs_super_compat_flags(super_block); 5502 newflags |= flags[0].compat_flags & flags[1].compat_flags; 5503 newflags &= ~(flags[0].compat_flags & ~flags[1].compat_flags); 5504 btrfs_set_super_compat_flags(super_block, newflags); 5505 5506 newflags = btrfs_super_compat_ro_flags(super_block); 5507 newflags |= flags[0].compat_ro_flags & flags[1].compat_ro_flags; 5508 newflags &= ~(flags[0].compat_ro_flags & ~flags[1].compat_ro_flags); 5509 btrfs_set_super_compat_ro_flags(super_block, newflags); 5510 5511 newflags = btrfs_super_incompat_flags(super_block); 5512 newflags |= flags[0].incompat_flags & flags[1].incompat_flags; 5513 newflags &= ~(flags[0].incompat_flags & ~flags[1].incompat_flags); 5514 btrfs_set_super_incompat_flags(super_block, newflags); 5515 spin_unlock(&fs_info->super_lock); 5516 5517 ret = btrfs_commit_transaction(trans); 5518 out_drop_write: 5519 mnt_drop_write_file(file); 5520 5521 return ret; 5522 } 5523 5524 static int _btrfs_ioctl_send(struct file *file, void __user *argp, bool compat) 5525 { 5526 struct btrfs_ioctl_send_args *arg; 5527 int ret; 5528 5529 if (compat) { 5530 #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT) 5531 struct btrfs_ioctl_send_args_32 args32; 5532 5533 ret = copy_from_user(&args32, argp, sizeof(args32)); 5534 if (ret) 5535 return -EFAULT; 5536 arg = kzalloc(sizeof(*arg), GFP_KERNEL); 5537 if (!arg) 5538 return -ENOMEM; 5539 arg->send_fd = args32.send_fd; 5540 arg->clone_sources_count = args32.clone_sources_count; 5541 arg->clone_sources = compat_ptr(args32.clone_sources); 5542 arg->parent_root = args32.parent_root; 5543 arg->flags = args32.flags; 5544 memcpy(arg->reserved, args32.reserved, 5545 sizeof(args32.reserved)); 5546 #else 5547 return -ENOTTY; 5548 #endif 5549 } else { 5550 arg = memdup_user(argp, sizeof(*arg)); 5551 if (IS_ERR(arg)) 5552 return PTR_ERR(arg); 5553 } 5554 ret = btrfs_ioctl_send(file, arg); 5555 kfree(arg); 5556 return ret; 5557 } 5558 5559 long btrfs_ioctl(struct file *file, unsigned int 5560 cmd, unsigned long arg) 5561 { 5562 struct inode *inode = file_inode(file); 5563 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 5564 struct btrfs_root *root = BTRFS_I(inode)->root; 5565 void __user *argp = (void __user *)arg; 5566 5567 switch (cmd) { 5568 case FS_IOC_GETFLAGS: 5569 return btrfs_ioctl_getflags(file, argp); 5570 case FS_IOC_SETFLAGS: 5571 return btrfs_ioctl_setflags(file, argp); 5572 case FS_IOC_GETVERSION: 5573 return btrfs_ioctl_getversion(file, argp); 5574 case FITRIM: 5575 return btrfs_ioctl_fitrim(file, argp); 5576 case BTRFS_IOC_SNAP_CREATE: 5577 return btrfs_ioctl_snap_create(file, argp, 0); 5578 case BTRFS_IOC_SNAP_CREATE_V2: 5579 return btrfs_ioctl_snap_create_v2(file, argp, 0); 5580 case BTRFS_IOC_SUBVOL_CREATE: 5581 return btrfs_ioctl_snap_create(file, argp, 1); 5582 case BTRFS_IOC_SUBVOL_CREATE_V2: 5583 return btrfs_ioctl_snap_create_v2(file, argp, 1); 5584 case BTRFS_IOC_SNAP_DESTROY: 5585 return btrfs_ioctl_snap_destroy(file, argp); 5586 case BTRFS_IOC_SUBVOL_GETFLAGS: 5587 return btrfs_ioctl_subvol_getflags(file, argp); 5588 case BTRFS_IOC_SUBVOL_SETFLAGS: 5589 return btrfs_ioctl_subvol_setflags(file, argp); 5590 case BTRFS_IOC_DEFAULT_SUBVOL: 5591 return btrfs_ioctl_default_subvol(file, argp); 5592 case BTRFS_IOC_DEFRAG: 5593 return btrfs_ioctl_defrag(file, NULL); 5594 case BTRFS_IOC_DEFRAG_RANGE: 5595 return btrfs_ioctl_defrag(file, argp); 5596 case BTRFS_IOC_RESIZE: 5597 return btrfs_ioctl_resize(file, argp); 5598 case BTRFS_IOC_ADD_DEV: 5599 return btrfs_ioctl_add_dev(fs_info, argp); 5600 case BTRFS_IOC_RM_DEV: 5601 return btrfs_ioctl_rm_dev(file, argp); 5602 case BTRFS_IOC_RM_DEV_V2: 5603 return btrfs_ioctl_rm_dev_v2(file, argp); 5604 case BTRFS_IOC_FS_INFO: 5605 return btrfs_ioctl_fs_info(fs_info, argp); 5606 case BTRFS_IOC_DEV_INFO: 5607 return btrfs_ioctl_dev_info(fs_info, argp); 5608 case BTRFS_IOC_BALANCE: 5609 return btrfs_ioctl_balance(file, NULL); 5610 case BTRFS_IOC_TREE_SEARCH: 5611 return btrfs_ioctl_tree_search(file, argp); 5612 case BTRFS_IOC_TREE_SEARCH_V2: 5613 return btrfs_ioctl_tree_search_v2(file, argp); 5614 case BTRFS_IOC_INO_LOOKUP: 5615 return btrfs_ioctl_ino_lookup(file, argp); 5616 case BTRFS_IOC_INO_PATHS: 5617 return btrfs_ioctl_ino_to_path(root, argp); 5618 case BTRFS_IOC_LOGICAL_INO: 5619 return btrfs_ioctl_logical_to_ino(fs_info, argp, 1); 5620 case BTRFS_IOC_LOGICAL_INO_V2: 5621 return btrfs_ioctl_logical_to_ino(fs_info, argp, 2); 5622 case BTRFS_IOC_SPACE_INFO: 5623 return btrfs_ioctl_space_info(fs_info, argp); 5624 case BTRFS_IOC_SYNC: { 5625 int ret; 5626 5627 ret = btrfs_start_delalloc_roots(fs_info, -1); 5628 if (ret) 5629 return ret; 5630 ret = btrfs_sync_fs(inode->i_sb, 1); 5631 /* 5632 * The transaction thread may want to do more work, 5633 * namely it pokes the cleaner kthread that will start 5634 * processing uncleaned subvols. 5635 */ 5636 wake_up_process(fs_info->transaction_kthread); 5637 return ret; 5638 } 5639 case BTRFS_IOC_START_SYNC: 5640 return btrfs_ioctl_start_sync(root, argp); 5641 case BTRFS_IOC_WAIT_SYNC: 5642 return btrfs_ioctl_wait_sync(fs_info, argp); 5643 case BTRFS_IOC_SCRUB: 5644 return btrfs_ioctl_scrub(file, argp); 5645 case BTRFS_IOC_SCRUB_CANCEL: 5646 return btrfs_ioctl_scrub_cancel(fs_info); 5647 case BTRFS_IOC_SCRUB_PROGRESS: 5648 return btrfs_ioctl_scrub_progress(fs_info, argp); 5649 case BTRFS_IOC_BALANCE_V2: 5650 return btrfs_ioctl_balance(file, argp); 5651 case BTRFS_IOC_BALANCE_CTL: 5652 return btrfs_ioctl_balance_ctl(fs_info, arg); 5653 case BTRFS_IOC_BALANCE_PROGRESS: 5654 return btrfs_ioctl_balance_progress(fs_info, argp); 5655 case BTRFS_IOC_SET_RECEIVED_SUBVOL: 5656 return btrfs_ioctl_set_received_subvol(file, argp); 5657 #ifdef CONFIG_64BIT 5658 case BTRFS_IOC_SET_RECEIVED_SUBVOL_32: 5659 return btrfs_ioctl_set_received_subvol_32(file, argp); 5660 #endif 5661 case BTRFS_IOC_SEND: 5662 return _btrfs_ioctl_send(file, argp, false); 5663 #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT) 5664 case BTRFS_IOC_SEND_32: 5665 return _btrfs_ioctl_send(file, argp, true); 5666 #endif 5667 case BTRFS_IOC_GET_DEV_STATS: 5668 return btrfs_ioctl_get_dev_stats(fs_info, argp); 5669 case BTRFS_IOC_QUOTA_CTL: 5670 return btrfs_ioctl_quota_ctl(file, argp); 5671 case BTRFS_IOC_QGROUP_ASSIGN: 5672 return btrfs_ioctl_qgroup_assign(file, argp); 5673 case BTRFS_IOC_QGROUP_CREATE: 5674 return btrfs_ioctl_qgroup_create(file, argp); 5675 case BTRFS_IOC_QGROUP_LIMIT: 5676 return btrfs_ioctl_qgroup_limit(file, argp); 5677 case BTRFS_IOC_QUOTA_RESCAN: 5678 return btrfs_ioctl_quota_rescan(file, argp); 5679 case BTRFS_IOC_QUOTA_RESCAN_STATUS: 5680 return btrfs_ioctl_quota_rescan_status(file, argp); 5681 case BTRFS_IOC_QUOTA_RESCAN_WAIT: 5682 return btrfs_ioctl_quota_rescan_wait(file, argp); 5683 case BTRFS_IOC_DEV_REPLACE: 5684 return btrfs_ioctl_dev_replace(fs_info, argp); 5685 case BTRFS_IOC_GET_FSLABEL: 5686 return btrfs_ioctl_get_fslabel(file, argp); 5687 case BTRFS_IOC_SET_FSLABEL: 5688 return btrfs_ioctl_set_fslabel(file, argp); 5689 case BTRFS_IOC_GET_SUPPORTED_FEATURES: 5690 return btrfs_ioctl_get_supported_features(argp); 5691 case BTRFS_IOC_GET_FEATURES: 5692 return btrfs_ioctl_get_features(file, argp); 5693 case BTRFS_IOC_SET_FEATURES: 5694 return btrfs_ioctl_set_features(file, argp); 5695 case FS_IOC_FSGETXATTR: 5696 return btrfs_ioctl_fsgetxattr(file, argp); 5697 case FS_IOC_FSSETXATTR: 5698 return btrfs_ioctl_fssetxattr(file, argp); 5699 case BTRFS_IOC_GET_SUBVOL_INFO: 5700 return btrfs_ioctl_get_subvol_info(file, argp); 5701 case BTRFS_IOC_GET_SUBVOL_ROOTREF: 5702 return btrfs_ioctl_get_subvol_rootref(file, argp); 5703 case BTRFS_IOC_INO_LOOKUP_USER: 5704 return btrfs_ioctl_ino_lookup_user(file, argp); 5705 } 5706 5707 return -ENOTTY; 5708 } 5709 5710 #ifdef CONFIG_COMPAT 5711 long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 5712 { 5713 /* 5714 * These all access 32-bit values anyway so no further 5715 * handling is necessary. 5716 */ 5717 switch (cmd) { 5718 case FS_IOC32_GETFLAGS: 5719 cmd = FS_IOC_GETFLAGS; 5720 break; 5721 case FS_IOC32_SETFLAGS: 5722 cmd = FS_IOC_SETFLAGS; 5723 break; 5724 case FS_IOC32_GETVERSION: 5725 cmd = FS_IOC_GETVERSION; 5726 break; 5727 } 5728 5729 return btrfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); 5730 } 5731 #endif 5732